/* Include files */



#include "simstruc.h"

#include "fixedpoint.h"

#include "simtarget/slSimTgtLogLoadBlocksSfcnBridge.h"

#include "GCU_Model_genCode_sfun.h"

#include "c1_GCU_Model_genCode.h"

#define CHARTINSTANCE_CHARTNUMBER      (chartInstance->chartNumber)

#define CHARTINSTANCE_INSTANCENUMBER   (chartInstance->instanceNumber)

#include "GCU_Model_genCode_sfun_debug_macros.h"

#define _SF_MEX_LISTEN_FOR_CTRL_C(S)   sf_mex_listen_for_ctrl_c(S);



static void chart_debug_initialization(SimStruct *S, unsigned int

  fullDebuggerInitialization);

static void chart_debug_initialize_data_addresses(SimStruct *S);

static const mxArray* sf_opaque_get_hover_data_for_msg(void *chartInstance,

  int32_T msgSSID);



/* Type Definitions */



/* Named Constants */

#define c1_event_GearshiftUp           (2)

#define c1_event_GearshiftDown         (0)

#define c1_event_GearshiftSetNeutral   (1)

#define CALL_EVENT                     (-1)

#define c1_IN_NO_ACTIVE_CHILD          ((uint8_T)0U)

#define c1_IN_ACCELERATION             ((uint8_T)1U)

#define c1_IN_ACCELERATION_PID         ((uint8_T)2U)

#define c1_IN_AUTOCROSS                ((uint8_T)3U)

#define c1_IN_INIT                     ((uint8_T)4U)

#define c1_IN_MANUAL_MODES             ((uint8_T)5U)

#define c1_IN_ENDURANCE                ((uint8_T)1U)

#define c1_IN_SKIDPAD                  ((uint8_T)2U)

#define c1_IN_ACC                      ((uint8_T)1U)

#define c1_IN_DEFAULT                  ((uint8_T)2U)

#define c1_IN_ACTIVE                   ((uint8_T)1U)

#define c1_IN_STOPPING                 ((uint8_T)2U)

#define c1_IN_READY                    ((uint8_T)1U)

#define c1_IN_RELEASING                ((uint8_T)2U)

#define c1_IN_RUNNING                  ((uint8_T)3U)

#define c1_IN_START                    ((uint8_T)4U)

#define c1_IN_START_RELEASE            ((uint8_T)5U)

#define c1_b_IN_DEFAULT                ((uint8_T)1U)

#define c1_IN_LAUNCH                   ((uint8_T)2U)

#define c1_IN_LAUNCH0                  ((uint8_T)2U)

#define c1_IN_RELEASE                  ((uint8_T)2U)

#define c1_IN_RPM_LIMITER              ((uint8_T)3U)

#define c1_b_IN_RUNNING                ((uint8_T)4U)

#define c1_b_IN_START                  ((uint8_T)5U)

#define c1_IN_NEUTRAL                  ((uint8_T)1U)

#define c1_IN_NO_NEUTRAL               ((uint8_T)2U)

#define c1_IN_SET_NEUTRAL              ((uint8_T)3U)

#define c1_IN_UNSET_NEUTRAL            ((uint8_T)4U)

#define c1_IN_DOWNSHIFTING             ((uint8_T)1U)

#define c1_IN_DOWN_END                 ((uint8_T)2U)

#define c1_IN_IDLE                     ((uint8_T)3U)

#define c1_IN_UPSHIFTING               ((uint8_T)5U)

#define c1_IN_UP_END                   ((uint8_T)6U)

#define c1_IN_UP_BRAKE                 ((uint8_T)1U)

#define c1_IN_UP_PUSH                  ((uint8_T)2U)

#define c1_IN_UP_REBOUND               ((uint8_T)3U)

#define c1_IN_UP_START                 ((uint8_T)4U)

#define c1_IN_Default                  ((uint8_T)1U)

#define c1_IN_SettingNeutral           ((uint8_T)2U)

#define c1_IN_CutOff                   ((uint8_T)1U)

#define c1_b_IN_Default                ((uint8_T)2U)

#define c1_IN_DOWN_BRAKE               ((uint8_T)1U)

#define c1_IN_DOWN_PUSH                ((uint8_T)2U)

#define c1_IN_DOWN_REBOUND             ((uint8_T)3U)

#define c1_IN_DOWN_START               ((uint8_T)4U)

#define c1_IN_ChangeClutch             ((uint8_T)1U)

#define c1_b_IN_SettingNeutral         ((uint8_T)3U)

#define c1_IN_SEND                     ((uint8_T)1U)

#define c1_IN_WAIT                     ((uint8_T)2U)

#define c1_c_IN_START                  ((uint8_T)1U)

#define c1_IN_STOP                     ((uint8_T)2U)

#define c1_b_IN_WAIT                   ((uint8_T)3U)

#define c1_IN_SCAN                     ((uint8_T)1U)

#define c1_IN_DISABLE                  ((uint8_T)1U)

#define c1_IN_ENABLE                   ((uint8_T)2U)

#define c1_const_GEAR_COMMAND_NEUTRAL_UP ((uint16_T)50U)

#define c1_const_GEAR_COMMAND_NEUTRAL_DOWN ((uint16_T)100U)

#define c1_const_GEAR_COMMAND_UP       ((uint16_T)400U)

#define c1_const_GEAR_COMMAND_DOWN     ((uint16_T)200U)

#define c1_const_AAC_WORK_RATE_ms      ((uint16_T)25U)

#define c1_const_DEF_RAMP_START        (50)

#define c1_const_DEF_RAMP_END          (0)

#define c1_const_DEF_RAMP_TIME         (250)

#define c1_const_DEF_RPM_LIMIT_1_2     (11000)

#define c1_const_DEF_RPM_LIMIT_2_3     (11000)

#define c1_const_DEF_RPM_LIMIT_3_4     (11000)

#define c1_const_DEF_RPM_LIMIT_4_5     (11000)

#define c1_const_DEF_SPEED_LIMIT_1_2   (46)

#define c1_const_DEF_SPEED_LIMIT_2_3   (61)

#define c1_const_DEF_SPEED_LIMIT_3_4   (77)

#define c1_const_DEF_SPEED_LIMIT_4_5   (113)

#define c1_const_ACC_CODE              ((uint16_T)1U)

#define c1_const_AUTOX_WORK_RATE_ms    ((uint16_T)25U)

#define c1_const_data                  (0.0)



/* Variable Declarations */



/* Variable Definitions */

static real_T _sfTime_;

static const char * c1_sv0[13] = { "RAMP_START", "RAMP_END", "RAMP_TIME",

  "RPM_LIMIT_1_2", "RPM_LIMIT_2_3", "RPM_LIMIT_3_4", "RPM_LIMIT_4_5",

  "SPEED_LIMIT_1_2", "SPEED_LIMIT_2_3", "SPEED_LIMIT_3_4", "SPEED_LIMIT_4_5",

  "TPS_START_LIMIT", "END_GEAR" };



static const int32_T c1_iv0[13] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };



static const char * c1_sv1[13] = { "AUTOX_RAMP_START", "AUTOX_RAMP_END",

  "AUTOX_RAMP_TIME", "AUTOX_RPM_LIMIT_1_2", "AUTOX_RPM_LIMIT_2_3",

  "AUTOX_RPM_LIMIT_3_4", "AUTOX_RPM_LIMIT_4_5", "AUTOX_SPEED_LIMIT_1_2",

  "AUTOX_SPEED_LIMIT_2_3", "AUTOX_SPEED_LIMIT_3_4", "AUTOX_SPEED_LIMIT_4_5",

  "AUTOX_TPS_START_LIMIT", "AUTOX_END_GEAR" };



/* Function Declarations */

static void c1_sdiInitialize(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_sdiTerminate(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void initialize_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void initialize_params_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void enable_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void disable_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_update_debugger_state_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static const mxArray *get_sim_state_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void set_sim_state_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance, const mxArray *c1_st);

static void c1_set_sim_state_side_effects_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void finalize_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void sf_gateway_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void mdl_start_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct *

  chartInstance);

static void c1_enter_internal_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void initSimStructsc1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_enter_atomic_MANUAL_MODES(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_MANUAL_MODES(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_MANUAL_MODES(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_INIT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_enter_atomic_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_enter_internal_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct *

  chartInstance);

static void c1_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_ACC(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_enter_atomic_READY(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_START_RELEASE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_RELEASING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_DEFAULT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_AUTOCROSS(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_AUTOCROSS(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_LAUNCH(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_b_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_b_exit_internal_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_b_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_b_enter_atomic_READY(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_b_START_RELEASE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_b_RELEASING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_b_DEFAULT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_enter_internal_ACCELERATION_PID

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_ACCELERATION_PID(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_exit_internal_ACCELERATION_PID

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_LAUNCH0(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_c_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_c_exit_internal_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_c_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_c_enter_atomic_READY(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_READY(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_c_DEFAULT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_NEUTRAL_STATE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_GEARSHIFT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_UPSHIFTING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_UP_REBOUND(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_exit_internal_UP_PUSH(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_UP_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_UP_START(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_IDLE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_DOWNSHIFTING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_DOWN_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_exit_internal_DOWN_START(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_exit_internal_DOWN_BRAKE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_START_ENGINE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void init_script_number_translation(uint32_T c1_machineNumber, uint32_T

  c1_chartNumber, uint32_T c1_instanceNumber);

static void c1_checkClutch(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_checkShift(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void c1_aacCheckShift(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static int32_T c1_getAacParam(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, c1_acc_params c1_index);

static void c1_autoXCheckShift(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static int32_T c1_getAutoXParam(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, c1_autoX_params c1_index);

static void c1_b_autoXCheckShift(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static int32_T c1_Gearshift_getTime(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void c1_Clutch_setValue(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, uint8_T c1_setValue);

static const mxArray *c1_sf_marshallOut(void *chartInstanceVoid, void *c1_inData);

static int32_T c1_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_sfEvent, const char_T *c1_identifier);

static int32_T c1_b_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_b_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static uint8_T c1_c_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_tp_MODES, const char_T *c1_identifier);

static uint8_T c1_d_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_b_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_c_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static void c1_e_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_lastModeCom, const char_T *c1_identifier,

  uint16_T c1_y[2]);

static void c1_f_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId,

  uint16_T c1_y[2]);

static void c1_c_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_d_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static const mxArray *c1_e_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static uint16_T c1_g_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_stateFb, const char_T *c1_identifier);

static uint16_T c1_h_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_d_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_f_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static const mxArray *c1_g_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static const mxArray *c1_h_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static const mxArray *c1_i_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static const mxArray *c1_j_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static uint32_T c1_i_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_pidCounter, const char_T *c1_identifier);

static uint32_T c1_j_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_e_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_k_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static void c1_k_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_lastTryShift, const char_T *c1_identifier,

  uint16_T c1_y[2]);

static void c1_l_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId,

  uint16_T c1_y[2]);

static void c1_f_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static real_T c1_m_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_aac_clutchValue, const char_T

  *c1_identifier);

static real_T c1_n_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_g_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_l_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static boolean_T c1_o_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_h_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_m_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static c1_acc_params c1_p_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct *

  chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static void c1_i_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static const mxArray *c1_n_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData);

static c1_autoX_params c1_q_emlrt_marshallIn

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance, const mxArray *c1_u,

   const emlrtMsgIdentifier *c1_parentId);

static void c1_j_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData);

static void c1_r_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u);

static const mxArray *c1_s_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_setSimStateSideEffectsInfo, const char_T

  *c1_identifier);

static const mxArray *c1_t_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId);

static const mxArray *sf_get_hover_data_for_msg

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance, int32_T c1_ssid);

static void c1_init_sf_message_store_memory(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static int32_T c1_div_nzp_s32(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_numerator, int32_T c1_denominator, uint32_T

  c1_ssid_src_loc, int32_T c1_offset_src_loc, int32_T c1_length_src_loc);

static int32_T c1__s32_add__(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance,

  int32_T c1_b, int32_T c1_c, uint32_T c1_ssid_src_loc, int32_T

  c1_offset_src_loc, int32_T c1_length_src_loc);

static int32_T c1__s32_minus__(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_b, int32_T c1_c, uint32_T c1_ssid_src_loc, int32_T

  c1_offset_src_loc, int32_T c1_length_src_loc);

static uint8_T c1__u8_s32_(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance,

  int32_T c1_b, uint32_T c1_ssid_src_loc, int32_T c1_offset_src_loc, int32_T

  c1_length_src_loc);

static void c1_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  int32_T c1_streamedData);

static void c1_b_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  void *c1_streamedData);

static void c1_c_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  int32_T c1_streamedData);

static void c1_d_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  void *c1_streamedData);

static void init_test_point_addr_map(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void **get_test_point_address_map(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static rtwCAPI_ModelMappingInfo *get_test_point_mapping_info

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void **get_dataset_logging_obj_vector

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance);

static void init_dsm_address_info(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);

static void init_simulink_io_address(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance);



/* Function Definitions */

static void c1_sdiInitialize(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  uint32_T c1_b[79] = { 0U, 418U, 820U, 434U, 538U, 545U, 544U, 514U, 543U, 547U,

    515U, 821U, 1157U, 1091U, 2174U, 2182U, 2192U, 2238U, 2848U, 2193U, 2191U,

    2223U, 951U, 952U, 974U, 985U, 999U, 1025U, 1002U, 998U, 1001U, 1028U, 429U,

    727U, 729U, 728U, 31U, 36U, 32U, 34U, 35U, 1U, 697U, 17U, 410U, 409U, 15U,

    16U, 14U, 2037U, 406U, 399U, 18U, 5U, 7U, 693U, 12U, 10U, 423U, 422U, 11U,

    390U, 391U, 9U, 385U, 383U, 13U, 479U, 482U, 483U, 494U, 929U, 932U, 940U,

    946U, 944U, 1069U, 1070U, 1072U };



  uint32_T c1_c[89] = { 123U, 834U, 443U, 485U, 524U, 680U, 715U, 799U, 833U,

    837U, 925U, 1044U, 1060U, 1067U, 1073U, 1083U, 1085U, 1183U, 1184U, 1185U,

    1186U, 1187U, 1188U, 1189U, 1191U, 1839U, 1891U, 1894U, 1904U, 2004U, 2851U,

    627U, 681U, 1043U, 1063U, 643U, 644U, 645U, 646U, 631U, 632U, 633U, 634U,

    537U, 550U, 561U, 563U, 564U, 698U, 699U, 700U, 702U, 704U, 705U, 706U, 707U,

    708U, 709U, 710U, 754U, 568U, 569U, 957U, 958U, 959U, 960U, 961U, 1031U,

    1032U, 2169U, 2170U, 2171U, 2172U, 2173U, 2239U, 2225U, 2226U, 45U, 437U,

    164U, 1889U, 1890U, 1892U, 501U, 950U, 484U, 488U, 938U, 1068U };



  const char * c1_d[6] = { "None", "ACCELERATION", "ACCELERATION_PID",

    "AUTOCROSS", "INIT", "MANUAL_MODES" };



  int32_T c1_e[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_f[25] = { "None", "INIT", "ENDURANCE", "SKIDPAD", "DEFAULT",

    "START", "READY", "START_RELEASE", "RELEASING", "RUNNING", "STOPPING",

    "DEFAULT", "START", "READY", "RELEASE", "RPM_LIMITER", "RUNNING", "STOPPING",

    "DEFAULT", "START", "READY", "START_RELEASE", "RELEASING", "RUNNING",

    "STOPPING" };



  int32_T c1_g[25] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

    17, 18, 19, 20, 21, 22, 23, 24 };



  const char * c1_h[3] = { "None", "ACC", "DEFAULT" };



  int32_T c1_i[3] = { 0, 1, 2 };



  const char * c1_j[8] = { "None", "DEFAULT", "START", "READY", "START_RELEASE",

    "RELEASING", "RUNNING", "STOPPING" };



  int32_T c1_k[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };



  const char * c1_l[3] = { "None", "ACTIVE", "STOPPING" };



  int32_T c1_m[3] = { 0, 1, 2 };



  const char * c1_n[7] = { "None", "START", "READY", "START_RELEASE",

    "RELEASING", "RUNNING", "STOPPING" };



  int32_T c1_o[7] = { 0, 1, 2, 3, 4, 5, 6 };



  const char * c1_p[6] = { "None", "READY", "RELEASING", "RUNNING", "START",

    "START_RELEASE" };



  int32_T c1_q[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_r[6] = { "None", "START", "READY", "START_RELEASE",

    "RELEASING", "RUNNING" };



  int32_T c1_s[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_t[3] = { "None", "DEFAULT", "LAUNCH0" };



  int32_T c1_u[3] = { 0, 1, 2 };



  const char * c1_v[8] = { "None", "DEFAULT", "START", "READY", "RELEASE",

    "RPM_LIMITER", "RUNNING", "STOPPING" };



  int32_T c1_w[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };



  const char * c1_x[3] = { "None", "ACTIVE", "STOPPING" };



  int32_T c1_y[3] = { 0, 1, 2 };



  const char * c1_ab[7] = { "None", "START", "READY", "RELEASE", "RPM_LIMITER",

    "RUNNING", "STOPPING" };



  int32_T c1_bb[7] = { 0, 1, 2, 3, 4, 5, 6 };



  const char * c1_cb[6] = { "None", "READY", "RELEASE", "RPM_LIMITER", "RUNNING",

    "START" };



  int32_T c1_db[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_eb[6] = { "None", "START", "READY", "RELEASE", "RPM_LIMITER",

    "RUNNING" };



  int32_T c1_fb[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_gb[3] = { "None", "DEFAULT", "LAUNCH" };



  int32_T c1_hb[3] = { 0, 1, 2 };



  const char * c1_ib[8] = { "None", "DEFAULT", "START", "READY", "START_RELEASE",

    "RELEASING", "RUNNING", "STOPPING" };



  int32_T c1_jb[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };



  const char * c1_kb[3] = { "None", "ACTIVE", "STOPPING" };



  int32_T c1_lb[3] = { 0, 1, 2 };



  const char * c1_mb[7] = { "None", "START", "READY", "START_RELEASE",

    "RELEASING", "RUNNING", "STOPPING" };



  int32_T c1_nb[7] = { 0, 1, 2, 3, 4, 5, 6 };



  const char * c1_ob[6] = { "None", "READY", "RELEASING", "RUNNING", "START",

    "START_RELEASE" };



  int32_T c1_pb[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_qb[6] = { "None", "START", "READY", "START_RELEASE",

    "RELEASING", "RUNNING" };



  int32_T c1_rb[6] = { 0, 1, 2, 3, 4, 5 };



  const char * c1_sb[3] = { "None", "ENDURANCE", "SKIDPAD" };



  int32_T c1_tb[3] = { 0, 1, 2 };



  const char * c1_ub[3] = { "None", "ENDURANCE", "SKIDPAD" };



  int32_T c1_vb[3] = { 0, 1, 2 };



  const char * c1_wb[5] = { "None", "NEUTRAL", "NO_NEUTRAL", "SET_NEUTRAL",

    "UNSET_NEUTRAL" };



  int32_T c1_xb[5] = { 0, 1, 2, 3, 4 };



  const char * c1_yb[5] = { "None", "NEUTRAL", "UNSET_NEUTRAL", "NO_NEUTRAL",

    "SET_NEUTRAL" };



  int32_T c1_ac[5] = { 0, 1, 2, 3, 4 };



  const char * c1_bc[7] = { "None", "DOWNSHIFTING", "DOWN_END", "IDLE", "INIT",

    "UPSHIFTING", "UP_END" };



  int32_T c1_cc[7] = { 0, 1, 2, 3, 4, 5, 6 };



  const char * c1_dc[19] = { "None", "INIT", "IDLE", "SettingNeutral", "Default",

    "CutOff", "Default", "SettingNeutral", "Default", "UP_BRAKE", "UP_END",

    "SettingNeutral", "ChangeClutch", "Default", "DOWN_PUSH", "DOWN_REBOUND",

    "ChangeClutch", "Default", "DOWN_END" };



  int32_T c1_ec[19] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

    17, 18 };



  const char * c1_fc[5] = { "None", "DOWN_BRAKE", "DOWN_PUSH", "DOWN_REBOUND",

    "DOWN_START" };



  int32_T c1_gc[5] = { 0, 1, 2, 3, 4 };



  const char * c1_hc[8] = { "None", "SettingNeutral", "ChangeClutch", "Default",

    "DOWN_PUSH", "DOWN_REBOUND", "ChangeClutch", "Default" };



  int32_T c1_ic[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };



  const char * c1_jc[3] = { "None", "ChangeClutch", "Default" };



  int32_T c1_kc[3] = { 0, 1, 2 };



  const char * c1_lc[3] = { "None", "ChangeClutch", "Default" };



  int32_T c1_mc[3] = { 0, 1, 2 };



  const char * c1_nc[4] = { "None", "ChangeClutch", "Default", "SettingNeutral"

  };



  int32_T c1_oc[4] = { 0, 1, 2, 3 };



  const char * c1_pc[4] = { "None", "SettingNeutral", "ChangeClutch", "Default"

  };



  int32_T c1_qc[4] = { 0, 1, 2, 3 };



  const char * c1_rc[5] = { "None", "UP_BRAKE", "UP_PUSH", "UP_REBOUND",

    "UP_START" };



  int32_T c1_sc[5] = { 0, 1, 2, 3, 4 };



  const char * c1_tc[8] = { "None", "SettingNeutral", "Default", "CutOff",

    "Default", "SettingNeutral", "Default", "UP_BRAKE" };



  int32_T c1_uc[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };



  const char * c1_vc[3] = { "None", "CutOff", "Default" };



  int32_T c1_wc[3] = { 0, 1, 2 };



  const char * c1_xc[3] = { "None", "CutOff", "Default" };



  int32_T c1_yc[3] = { 0, 1, 2 };



  const char * c1_ad[3] = { "None", "Default", "SettingNeutral" };



  int32_T c1_bd[3] = { 0, 1, 2 };



  const char * c1_cd[3] = { "None", "SettingNeutral", "Default" };



  int32_T c1_dd[3] = { 0, 1, 2 };



  const char * c1_ed[3] = { "None", "Default", "SettingNeutral" };



  int32_T c1_fd[3] = { 0, 1, 2 };



  const char * c1_gd[3] = { "None", "SettingNeutral", "Default" };



  int32_T c1_hd[3] = { 0, 1, 2 };



  const char * c1_id[4] = { "None", "START", "STOP", "WAIT" };



  int32_T c1_jd[4] = { 0, 1, 2, 3 };



  const char * c1_kd[4] = { "None", "WAIT", "START", "STOP" };



  int32_T c1_ld[4] = { 0, 1, 2, 3 };



  const char * c1_md[2] = { "None", "SCAN" };



  int32_T c1_nd[2] = { 0, 1 };



  const char * c1_od[2] = { "None", "SCAN" };



  int32_T c1_pd[2] = { 0, 1 };



  const char * c1_qd[3] = { "None", "SEND", "WAIT" };



  int32_T c1_rd[3] = { 0, 1, 2 };



  const char * c1_sd[3] = { "None", "WAIT", "SEND" };



  int32_T c1_td[3] = { 0, 1, 2 };



  const char * c1_ud[3] = { "None", "DISABLE", "ENABLE" };



  int32_T c1_vd[3] = { 0, 1, 2 };



  const char * c1_wd[3] = { "None", "DISABLE", "ENABLE" };



  int32_T c1_xd[3] = { 0, 1, 2 };



  int32_T c1_yd[1] = { 1 };



  int32_T c1_ae[1] = { 2 };



  int32_T c1_be[1] = { 1 };



  int32_T c1_ce[1] = { 1 };



  int32_T c1_de[1] = { 1 };



  int32_T c1_ee[1] = { 1 };



  int32_T c1_fe[2] = { 1, 2 };



  int32_T c1_ge[1] = { 1 };



  int32_T c1_he[1] = { 1 };



  int32_T c1_ie[1] = { 1 };



  int32_T c1_je[1] = { 1 };



  int32_T c1_ke[1] = { 1 };



  int32_T c1_le[1] = { 1 };



  int32_T c1_me[1] = { 1 };



  int32_T c1_ne[1] = { 1 };



  int32_T c1_oe[1] = { 1 };



  int32_T c1_pe[1] = { 1 };



  int32_T c1_qe[1] = { 1 };



  int32_T c1_re[1] = { 1 };



  int32_T c1_se[1] = { 1 };



  int32_T c1_te[1] = { 1 };



  int32_T c1_ue[1] = { 1 };



  int32_T c1_ve[1] = { 1 };



  int32_T c1_we[1] = { 1 };



  int32_T c1_xe[1] = { 1 };



  int32_T c1_ye[1] = { 1 };



  int32_T c1_af[1] = { 1 };



  int32_T c1_bf[1] = { 1 };



  int32_T c1_cf[1] = { 1 };



  int32_T c1_df[1] = { 1 };



  chartInstance->c1_sdiBlockInfo.mdlRefFullPath = "";

  chartInstance->c1_sdiBlockInfo.SimStruct = (void *)chartInstance->S;

  chartInstance->c1_sdiBlockInfo.blkPath = "";

  chartInstance->c1_sdiBlockInfo.blkSID = "GCU_Model_genCode:651";

  chartInstance->c1_sdiBlockInfo.sharedSCMPath = "";

  chartInstance->c1_sdiBlockInfo.sdiRuntime = NULL;

  sdi_database_initialize(&chartInstance->c1_sdiBlockInfo, c1_b, (uint8_T *)

    &chartInstance->c1_sdiLoggedStatesBuffer[0U], 79, c1_c, (uint8_T *)

    &chartInstance->c1_sdiLoggedDataBuffer[0U], 89);

  if (chartInstance->c1_sdiLoggedStatesBuffer[1U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo, "MODES",

      "MODES", 6, c1_d, c1_e, sizeof(uint8_T), 1, 418U);

  }



  chartInstance->c1_SignalExportProp.logName = "";

  chartInstance->c1_SignalExportProp.signalName = "MODES";

  chartInstance->c1_SignalExportProp.useCustomName = 0;

  chartInstance->c1_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_SignalExportProp.decimate = 0;

  chartInstance->c1_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[1U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo, "MODES",

      "MODES", 1, &chartInstance->c1_SignalExportProp, 418U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[1U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo, "MODES",

      "MODES", 25, c1_f, c1_g, 1, 418U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[2U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION", "MODES/ACCELERATION", 3, c1_h, c1_i, sizeof(uint8_T),

      1, 820U);

  }



  chartInstance->c1_b_SignalExportProp.logName = "";

  chartInstance->c1_b_SignalExportProp.signalName = "MODES.ACCELERATION";

  chartInstance->c1_b_SignalExportProp.useCustomName = 0;

  chartInstance->c1_b_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_b_SignalExportProp.decimate = 0;

  chartInstance->c1_b_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_b_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[2U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION", "MODES/ACCELERATION", 1,

      &chartInstance->c1_b_SignalExportProp, 820U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[2U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION", "MODES/ACCELERATION", 8, c1_j, c1_k, 1, 820U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[3U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC", "MODES/ACCELERATION/ACC", 3, c1_l, c1_m, sizeof

      (uint8_T), 1, 434U);

  }



  chartInstance->c1_c_SignalExportProp.logName = "";

  chartInstance->c1_c_SignalExportProp.signalName = "MODES.ACCELERATION.ACC";

  chartInstance->c1_c_SignalExportProp.useCustomName = 0;

  chartInstance->c1_c_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_c_SignalExportProp.decimate = 0;

  chartInstance->c1_c_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_c_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[3U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC", "MODES/ACCELERATION/ACC", 1,

      &chartInstance->c1_c_SignalExportProp, 434U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[3U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC", "MODES/ACCELERATION/ACC", 7, c1_n, c1_o, 1, 434U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[4U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE", "MODES/ACCELERATION/ACC/ACTIVE", 6, c1_p,

      c1_q, sizeof(uint8_T), 1, 538U);

  }



  chartInstance->c1_d_SignalExportProp.logName = "";

  chartInstance->c1_d_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.ACTIVE";

  chartInstance->c1_d_SignalExportProp.useCustomName = 0;

  chartInstance->c1_d_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_d_SignalExportProp.decimate = 0;

  chartInstance->c1_d_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_d_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[4U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE", "MODES/ACCELERATION/ACC/ACTIVE", 1,

      &chartInstance->c1_d_SignalExportProp, 538U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[4U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE", "MODES/ACCELERATION/ACC/ACTIVE", 6, c1_r,

      c1_s, 1, 538U);

  }



  chartInstance->c1_e_SignalExportProp.logName = "";

  chartInstance->c1_e_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.ACTIVE.READY";

  chartInstance->c1_e_SignalExportProp.useCustomName = 0;

  chartInstance->c1_e_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_e_SignalExportProp.decimate = 0;

  chartInstance->c1_e_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_e_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[5U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE.READY",

      "MODES/ACCELERATION/ACC/ACTIVE/READY", 1,

      &chartInstance->c1_e_SignalExportProp, 545U);

  }



  chartInstance->c1_f_SignalExportProp.logName = "";

  chartInstance->c1_f_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.ACTIVE.RELEASING";

  chartInstance->c1_f_SignalExportProp.useCustomName = 0;

  chartInstance->c1_f_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_f_SignalExportProp.decimate = 0;

  chartInstance->c1_f_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_f_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[6U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE.RELEASING",

      "MODES/ACCELERATION/ACC/ACTIVE/RELEASING", 1,

      &chartInstance->c1_f_SignalExportProp, 544U);

  }



  chartInstance->c1_g_SignalExportProp.logName = "";

  chartInstance->c1_g_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.ACTIVE.RUNNING";

  chartInstance->c1_g_SignalExportProp.useCustomName = 0;

  chartInstance->c1_g_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_g_SignalExportProp.decimate = 0;

  chartInstance->c1_g_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_g_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[7U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE.RUNNING",

      "MODES/ACCELERATION/ACC/ACTIVE/RUNNING", 1,

      &chartInstance->c1_g_SignalExportProp, 514U);

  }



  chartInstance->c1_h_SignalExportProp.logName = "";

  chartInstance->c1_h_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.ACTIVE.START";

  chartInstance->c1_h_SignalExportProp.useCustomName = 0;

  chartInstance->c1_h_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_h_SignalExportProp.decimate = 0;

  chartInstance->c1_h_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_h_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[8U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE.START",

      "MODES/ACCELERATION/ACC/ACTIVE/START", 1,

      &chartInstance->c1_h_SignalExportProp, 543U);

  }



  chartInstance->c1_i_SignalExportProp.logName = "";

  chartInstance->c1_i_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.ACTIVE.START_RELEASE";

  chartInstance->c1_i_SignalExportProp.useCustomName = 0;

  chartInstance->c1_i_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_i_SignalExportProp.decimate = 0;

  chartInstance->c1_i_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_i_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[9U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.ACTIVE.START_RELEASE",

      "MODES/ACCELERATION/ACC/ACTIVE/START_RELEASE", 1,

      &chartInstance->c1_i_SignalExportProp, 547U);

  }



  chartInstance->c1_j_SignalExportProp.logName = "";

  chartInstance->c1_j_SignalExportProp.signalName =

    "MODES.ACCELERATION.ACC.STOPPING";

  chartInstance->c1_j_SignalExportProp.useCustomName = 0;

  chartInstance->c1_j_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_j_SignalExportProp.decimate = 0;

  chartInstance->c1_j_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_j_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[10U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.ACC.STOPPING", "MODES/ACCELERATION/ACC/STOPPING", 1,

      &chartInstance->c1_j_SignalExportProp, 515U);

  }



  chartInstance->c1_k_SignalExportProp.logName = "";

  chartInstance->c1_k_SignalExportProp.signalName = "MODES.ACCELERATION.DEFAULT";

  chartInstance->c1_k_SignalExportProp.useCustomName = 0;

  chartInstance->c1_k_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_k_SignalExportProp.decimate = 0;

  chartInstance->c1_k_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_k_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[11U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION.DEFAULT", "MODES/ACCELERATION/DEFAULT", 1,

      &chartInstance->c1_k_SignalExportProp, 821U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[12U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID", "MODES/ACCELERATION_PID", 3, c1_t, c1_u, sizeof

      (uint8_T), 1, 1157U);

  }



  chartInstance->c1_l_SignalExportProp.logName = "";

  chartInstance->c1_l_SignalExportProp.signalName = "MODES.ACCELERATION_PID";

  chartInstance->c1_l_SignalExportProp.useCustomName = 0;

  chartInstance->c1_l_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_l_SignalExportProp.decimate = 0;

  chartInstance->c1_l_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_l_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[12U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID", "MODES/ACCELERATION_PID", 1,

      &chartInstance->c1_l_SignalExportProp, 1157U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[12U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID", "MODES/ACCELERATION_PID", 8, c1_v, c1_w, 1,

      1157U);

  }



  chartInstance->c1_m_SignalExportProp.logName = "";

  chartInstance->c1_m_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.DEFAULT";

  chartInstance->c1_m_SignalExportProp.useCustomName = 0;

  chartInstance->c1_m_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_m_SignalExportProp.decimate = 0;

  chartInstance->c1_m_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_m_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[13U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.DEFAULT", "MODES/ACCELERATION_PID/DEFAULT", 1,

      &chartInstance->c1_m_SignalExportProp, 1091U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[14U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0", "MODES/ACCELERATION_PID/LAUNCH0", 3,

      c1_x, c1_y, sizeof(uint8_T), 1, 2174U);

  }



  chartInstance->c1_n_SignalExportProp.logName = "";

  chartInstance->c1_n_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0";

  chartInstance->c1_n_SignalExportProp.useCustomName = 0;

  chartInstance->c1_n_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_n_SignalExportProp.decimate = 0;

  chartInstance->c1_n_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_n_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[14U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0", "MODES/ACCELERATION_PID/LAUNCH0", 1,

      &chartInstance->c1_n_SignalExportProp, 2174U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[14U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0", "MODES/ACCELERATION_PID/LAUNCH0", 7,

      c1_ab, c1_bb, 1, 2174U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[15U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE", 6, c1_cb, c1_db, sizeof(uint8_T),

      1, 2182U);

  }



  chartInstance->c1_o_SignalExportProp.logName = "";

  chartInstance->c1_o_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE";

  chartInstance->c1_o_SignalExportProp.useCustomName = 0;

  chartInstance->c1_o_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_o_SignalExportProp.decimate = 0;

  chartInstance->c1_o_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_o_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[15U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE", 1,

      &chartInstance->c1_o_SignalExportProp, 2182U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[15U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE", 6, c1_eb, c1_fb, 1, 2182U);

  }



  chartInstance->c1_p_SignalExportProp.logName = "";

  chartInstance->c1_p_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.READY";

  chartInstance->c1_p_SignalExportProp.useCustomName = 0;

  chartInstance->c1_p_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_p_SignalExportProp.decimate = 0;

  chartInstance->c1_p_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_p_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[16U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.READY",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE/READY", 1,

      &chartInstance->c1_p_SignalExportProp, 2192U);

  }



  chartInstance->c1_q_SignalExportProp.logName = "";

  chartInstance->c1_q_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.RELEASE";

  chartInstance->c1_q_SignalExportProp.useCustomName = 0;

  chartInstance->c1_q_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_q_SignalExportProp.decimate = 0;

  chartInstance->c1_q_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_q_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[17U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.RELEASE",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE/RELEASE", 1,

      &chartInstance->c1_q_SignalExportProp, 2238U);

  }



  chartInstance->c1_r_SignalExportProp.logName = "";

  chartInstance->c1_r_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.RPM_LIMITER";

  chartInstance->c1_r_SignalExportProp.useCustomName = 0;

  chartInstance->c1_r_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_r_SignalExportProp.decimate = 0;

  chartInstance->c1_r_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_r_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[18U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.RPM_LIMITER",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE/RPM_LIMITER", 1,

      &chartInstance->c1_r_SignalExportProp, 2848U);

  }



  chartInstance->c1_s_SignalExportProp.logName = "";

  chartInstance->c1_s_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.RUNNING";

  chartInstance->c1_s_SignalExportProp.useCustomName = 0;

  chartInstance->c1_s_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_s_SignalExportProp.decimate = 0;

  chartInstance->c1_s_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_s_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[19U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.RUNNING",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE/RUNNING", 1,

      &chartInstance->c1_s_SignalExportProp, 2193U);

  }



  chartInstance->c1_t_SignalExportProp.logName = "";

  chartInstance->c1_t_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.START";

  chartInstance->c1_t_SignalExportProp.useCustomName = 0;

  chartInstance->c1_t_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_t_SignalExportProp.decimate = 0;

  chartInstance->c1_t_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_t_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[20U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.ACTIVE.START",

      "MODES/ACCELERATION_PID/LAUNCH0/ACTIVE/START", 1,

      &chartInstance->c1_t_SignalExportProp, 2191U);

  }



  chartInstance->c1_u_SignalExportProp.logName = "";

  chartInstance->c1_u_SignalExportProp.signalName =

    "MODES.ACCELERATION_PID.LAUNCH0.STOPPING";

  chartInstance->c1_u_SignalExportProp.useCustomName = 0;

  chartInstance->c1_u_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_u_SignalExportProp.decimate = 0;

  chartInstance->c1_u_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_u_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[21U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.ACCELERATION_PID.LAUNCH0.STOPPING",

      "MODES/ACCELERATION_PID/LAUNCH0/STOPPING", 1,

      &chartInstance->c1_u_SignalExportProp, 2223U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[22U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS", "MODES/AUTOCROSS", 3, c1_gb, c1_hb, sizeof(uint8_T), 1,

      951U);

  }



  chartInstance->c1_v_SignalExportProp.logName = "";

  chartInstance->c1_v_SignalExportProp.signalName = "MODES.AUTOCROSS";

  chartInstance->c1_v_SignalExportProp.useCustomName = 0;

  chartInstance->c1_v_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_v_SignalExportProp.decimate = 0;

  chartInstance->c1_v_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_v_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[22U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS", "MODES/AUTOCROSS", 1,

      &chartInstance->c1_v_SignalExportProp, 951U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[22U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS", "MODES/AUTOCROSS", 8, c1_ib, c1_jb, 1, 951U);

  }



  chartInstance->c1_w_SignalExportProp.logName = "";

  chartInstance->c1_w_SignalExportProp.signalName = "MODES.AUTOCROSS.DEFAULT";

  chartInstance->c1_w_SignalExportProp.useCustomName = 0;

  chartInstance->c1_w_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_w_SignalExportProp.decimate = 0;

  chartInstance->c1_w_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_w_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[23U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.DEFAULT", "MODES/AUTOCROSS/DEFAULT", 1,

      &chartInstance->c1_w_SignalExportProp, 952U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[24U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH", "MODES/AUTOCROSS/LAUNCH", 3, c1_kb, c1_lb,

      sizeof(uint8_T), 1, 974U);

  }



  chartInstance->c1_x_SignalExportProp.logName = "";

  chartInstance->c1_x_SignalExportProp.signalName = "MODES.AUTOCROSS.LAUNCH";

  chartInstance->c1_x_SignalExportProp.useCustomName = 0;

  chartInstance->c1_x_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_x_SignalExportProp.decimate = 0;

  chartInstance->c1_x_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_x_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[24U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH", "MODES/AUTOCROSS/LAUNCH", 1,

      &chartInstance->c1_x_SignalExportProp, 974U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[24U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH", "MODES/AUTOCROSS/LAUNCH", 7, c1_mb, c1_nb, 1,

      974U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[25U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE", "MODES/AUTOCROSS/LAUNCH/ACTIVE", 6, c1_ob,

      c1_pb, sizeof(uint8_T), 1, 985U);

  }



  chartInstance->c1_y_SignalExportProp.logName = "";

  chartInstance->c1_y_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.ACTIVE";

  chartInstance->c1_y_SignalExportProp.useCustomName = 0;

  chartInstance->c1_y_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_y_SignalExportProp.decimate = 0;

  chartInstance->c1_y_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_y_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[25U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE", "MODES/AUTOCROSS/LAUNCH/ACTIVE", 1,

      &chartInstance->c1_y_SignalExportProp, 985U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[25U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE", "MODES/AUTOCROSS/LAUNCH/ACTIVE", 6, c1_qb,

      c1_rb, 1, 985U);

  }



  chartInstance->c1_ab_SignalExportProp.logName = "";

  chartInstance->c1_ab_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.ACTIVE.READY";

  chartInstance->c1_ab_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ab_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ab_SignalExportProp.decimate = 0;

  chartInstance->c1_ab_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ab_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[26U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE.READY",

      "MODES/AUTOCROSS/LAUNCH/ACTIVE/READY", 1,

      &chartInstance->c1_ab_SignalExportProp, 999U);

  }



  chartInstance->c1_bb_SignalExportProp.logName = "";

  chartInstance->c1_bb_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.ACTIVE.RELEASING";

  chartInstance->c1_bb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_bb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_bb_SignalExportProp.decimate = 0;

  chartInstance->c1_bb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_bb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[27U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE.RELEASING",

      "MODES/AUTOCROSS/LAUNCH/ACTIVE/RELEASING", 1,

      &chartInstance->c1_bb_SignalExportProp, 1025U);

  }



  chartInstance->c1_cb_SignalExportProp.logName = "";

  chartInstance->c1_cb_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.ACTIVE.RUNNING";

  chartInstance->c1_cb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_cb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_cb_SignalExportProp.decimate = 0;

  chartInstance->c1_cb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_cb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[28U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE.RUNNING",

      "MODES/AUTOCROSS/LAUNCH/ACTIVE/RUNNING", 1,

      &chartInstance->c1_cb_SignalExportProp, 1002U);

  }



  chartInstance->c1_db_SignalExportProp.logName = "";

  chartInstance->c1_db_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.ACTIVE.START";

  chartInstance->c1_db_SignalExportProp.useCustomName = 0;

  chartInstance->c1_db_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_db_SignalExportProp.decimate = 0;

  chartInstance->c1_db_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_db_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[29U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE.START",

      "MODES/AUTOCROSS/LAUNCH/ACTIVE/START", 1,

      &chartInstance->c1_db_SignalExportProp, 998U);

  }



  chartInstance->c1_eb_SignalExportProp.logName = "";

  chartInstance->c1_eb_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.ACTIVE.START_RELEASE";

  chartInstance->c1_eb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_eb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_eb_SignalExportProp.decimate = 0;

  chartInstance->c1_eb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_eb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[30U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.ACTIVE.START_RELEASE",

      "MODES/AUTOCROSS/LAUNCH/ACTIVE/START_RELEASE", 1,

      &chartInstance->c1_eb_SignalExportProp, 1001U);

  }



  chartInstance->c1_fb_SignalExportProp.logName = "";

  chartInstance->c1_fb_SignalExportProp.signalName =

    "MODES.AUTOCROSS.LAUNCH.STOPPING";

  chartInstance->c1_fb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_fb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_fb_SignalExportProp.decimate = 0;

  chartInstance->c1_fb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_fb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[31U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.AUTOCROSS.LAUNCH.STOPPING", "MODES/AUTOCROSS/LAUNCH/STOPPING", 1,

      &chartInstance->c1_fb_SignalExportProp, 1028U);

  }



  chartInstance->c1_gb_SignalExportProp.logName = "";

  chartInstance->c1_gb_SignalExportProp.signalName = "MODES.INIT";

  chartInstance->c1_gb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_gb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_gb_SignalExportProp.decimate = 0;

  chartInstance->c1_gb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_gb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[32U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.INIT", "MODES/INIT", 1, &chartInstance->c1_gb_SignalExportProp,

      429U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[33U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.MANUAL_MODES", "MODES/MANUAL_MODES", 3, c1_sb, c1_tb, sizeof

      (uint8_T), 1, 727U);

  }



  chartInstance->c1_hb_SignalExportProp.logName = "";

  chartInstance->c1_hb_SignalExportProp.signalName = "MODES.MANUAL_MODES";

  chartInstance->c1_hb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_hb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_hb_SignalExportProp.decimate = 0;

  chartInstance->c1_hb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_hb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[33U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.MANUAL_MODES", "MODES/MANUAL_MODES", 1,

      &chartInstance->c1_hb_SignalExportProp, 727U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[33U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.MANUAL_MODES", "MODES/MANUAL_MODES", 3, c1_ub, c1_vb, 1, 727U);

  }



  chartInstance->c1_ib_SignalExportProp.logName = "";

  chartInstance->c1_ib_SignalExportProp.signalName =

    "MODES.MANUAL_MODES.ENDURANCE";

  chartInstance->c1_ib_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ib_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ib_SignalExportProp.decimate = 0;

  chartInstance->c1_ib_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ib_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[34U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.MANUAL_MODES.ENDURANCE", "MODES/MANUAL_MODES/ENDURANCE", 1,

      &chartInstance->c1_ib_SignalExportProp, 729U);

  }



  chartInstance->c1_jb_SignalExportProp.logName = "";

  chartInstance->c1_jb_SignalExportProp.signalName =

    "MODES.MANUAL_MODES.SKIDPAD";

  chartInstance->c1_jb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_jb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_jb_SignalExportProp.decimate = 0;

  chartInstance->c1_jb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_jb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[35U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "MODES.MANUAL_MODES.SKIDPAD", "MODES/MANUAL_MODES/SKIDPAD", 1,

      &chartInstance->c1_jb_SignalExportProp, 728U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[36U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE", "NEUTRAL_STATE", 5, c1_wb, c1_xb, sizeof(uint8_T), 1, 31U);

  }



  chartInstance->c1_kb_SignalExportProp.logName = "";

  chartInstance->c1_kb_SignalExportProp.signalName = "NEUTRAL_STATE";

  chartInstance->c1_kb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_kb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_kb_SignalExportProp.decimate = 0;

  chartInstance->c1_kb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_kb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[36U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE", "NEUTRAL_STATE", 1,

      &chartInstance->c1_kb_SignalExportProp, 31U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[36U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE", "NEUTRAL_STATE", 5, c1_yb, c1_ac, 1, 31U);

  }



  chartInstance->c1_lb_SignalExportProp.logName = "";

  chartInstance->c1_lb_SignalExportProp.signalName = "NEUTRAL_STATE.NEUTRAL";

  chartInstance->c1_lb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_lb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_lb_SignalExportProp.decimate = 0;

  chartInstance->c1_lb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_lb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[37U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE.NEUTRAL", "NEUTRAL_STATE/NEUTRAL", 1,

      &chartInstance->c1_lb_SignalExportProp, 36U);

  }



  chartInstance->c1_mb_SignalExportProp.logName = "";

  chartInstance->c1_mb_SignalExportProp.signalName = "NEUTRAL_STATE.NO_NEUTRAL";

  chartInstance->c1_mb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_mb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_mb_SignalExportProp.decimate = 0;

  chartInstance->c1_mb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_mb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[38U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE.NO_NEUTRAL", "NEUTRAL_STATE/NO_NEUTRAL", 1,

      &chartInstance->c1_mb_SignalExportProp, 32U);

  }



  chartInstance->c1_nb_SignalExportProp.logName = "";

  chartInstance->c1_nb_SignalExportProp.signalName = "NEUTRAL_STATE.SET_NEUTRAL";

  chartInstance->c1_nb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_nb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_nb_SignalExportProp.decimate = 0;

  chartInstance->c1_nb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_nb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[39U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE.SET_NEUTRAL", "NEUTRAL_STATE/SET_NEUTRAL", 1,

      &chartInstance->c1_nb_SignalExportProp, 34U);

  }



  chartInstance->c1_ob_SignalExportProp.logName = "";

  chartInstance->c1_ob_SignalExportProp.signalName =

    "NEUTRAL_STATE.UNSET_NEUTRAL";

  chartInstance->c1_ob_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ob_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ob_SignalExportProp.decimate = 0;

  chartInstance->c1_ob_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ob_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[40U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "NEUTRAL_STATE.UNSET_NEUTRAL", "NEUTRAL_STATE/UNSET_NEUTRAL", 1,

      &chartInstance->c1_ob_SignalExportProp, 35U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[41U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT", "GEARSHIFT", 7, c1_bc, c1_cc, sizeof(uint8_T), 1, 1U);

  }



  chartInstance->c1_pb_SignalExportProp.logName = "";

  chartInstance->c1_pb_SignalExportProp.signalName = "GEARSHIFT";

  chartInstance->c1_pb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_pb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_pb_SignalExportProp.decimate = 0;

  chartInstance->c1_pb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_pb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[41U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT", "GEARSHIFT", 1, &chartInstance->c1_pb_SignalExportProp, 1U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[41U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT", "GEARSHIFT", 19, c1_dc, c1_ec, 1, 1U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[42U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING", "GEARSHIFT/DOWNSHIFTING", 5, c1_fc, c1_gc,

      sizeof(uint8_T), 1, 697U);

  }



  chartInstance->c1_qb_SignalExportProp.logName = "";

  chartInstance->c1_qb_SignalExportProp.signalName = "GEARSHIFT.DOWNSHIFTING";

  chartInstance->c1_qb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_qb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_qb_SignalExportProp.decimate = 0;

  chartInstance->c1_qb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_qb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[42U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING", "GEARSHIFT/DOWNSHIFTING", 1,

      &chartInstance->c1_qb_SignalExportProp, 697U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[42U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING", "GEARSHIFT/DOWNSHIFTING", 8, c1_hc, c1_ic, 1,

      697U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[43U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE", "GEARSHIFT/DOWNSHIFTING/DOWN_BRAKE",

      3, c1_jc, c1_kc, sizeof(uint8_T), 1, 17U);

  }



  chartInstance->c1_rb_SignalExportProp.logName = "";

  chartInstance->c1_rb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE";

  chartInstance->c1_rb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_rb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_rb_SignalExportProp.decimate = 0;

  chartInstance->c1_rb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_rb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[43U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE", "GEARSHIFT/DOWNSHIFTING/DOWN_BRAKE",

      1, &chartInstance->c1_rb_SignalExportProp, 17U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[43U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE", "GEARSHIFT/DOWNSHIFTING/DOWN_BRAKE",

      3, c1_lc, c1_mc, 1, 17U);

  }



  chartInstance->c1_sb_SignalExportProp.logName = "";

  chartInstance->c1_sb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE.ChangeClutch";

  chartInstance->c1_sb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_sb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_sb_SignalExportProp.decimate = 0;

  chartInstance->c1_sb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_sb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[44U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE.ChangeClutch",

      "GEARSHIFT/DOWNSHIFTING/DOWN_BRAKE/ChangeClutch", 1,

      &chartInstance->c1_sb_SignalExportProp, 410U);

  }



  chartInstance->c1_tb_SignalExportProp.logName = "";

  chartInstance->c1_tb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE.Default";

  chartInstance->c1_tb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_tb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_tb_SignalExportProp.decimate = 0;

  chartInstance->c1_tb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_tb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[45U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_BRAKE.Default",

      "GEARSHIFT/DOWNSHIFTING/DOWN_BRAKE/Default", 1,

      &chartInstance->c1_tb_SignalExportProp, 409U);

  }



  chartInstance->c1_ub_SignalExportProp.logName = "";

  chartInstance->c1_ub_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_PUSH";

  chartInstance->c1_ub_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ub_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ub_SignalExportProp.decimate = 0;

  chartInstance->c1_ub_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ub_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[46U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_PUSH", "GEARSHIFT/DOWNSHIFTING/DOWN_PUSH", 1,

      &chartInstance->c1_ub_SignalExportProp, 15U);

  }



  chartInstance->c1_vb_SignalExportProp.logName = "";

  chartInstance->c1_vb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_REBOUND";

  chartInstance->c1_vb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_vb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_vb_SignalExportProp.decimate = 0;

  chartInstance->c1_vb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_vb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[47U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_REBOUND",

      "GEARSHIFT/DOWNSHIFTING/DOWN_REBOUND", 1,

      &chartInstance->c1_vb_SignalExportProp, 16U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[48U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_START", "GEARSHIFT/DOWNSHIFTING/DOWN_START",

      4, c1_nc, c1_oc, sizeof(uint8_T), 1, 14U);

  }



  chartInstance->c1_wb_SignalExportProp.logName = "";

  chartInstance->c1_wb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_START";

  chartInstance->c1_wb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_wb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_wb_SignalExportProp.decimate = 0;

  chartInstance->c1_wb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_wb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[48U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_START", "GEARSHIFT/DOWNSHIFTING/DOWN_START",

      1, &chartInstance->c1_wb_SignalExportProp, 14U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[48U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_START", "GEARSHIFT/DOWNSHIFTING/DOWN_START",

      4, c1_pc, c1_qc, 1, 14U);

  }



  chartInstance->c1_xb_SignalExportProp.logName = "";

  chartInstance->c1_xb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_START.ChangeClutch";

  chartInstance->c1_xb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_xb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_xb_SignalExportProp.decimate = 0;

  chartInstance->c1_xb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_xb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[49U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_START.ChangeClutch",

      "GEARSHIFT/DOWNSHIFTING/DOWN_START/ChangeClutch", 1,

      &chartInstance->c1_xb_SignalExportProp, 2037U);

  }



  chartInstance->c1_yb_SignalExportProp.logName = "";

  chartInstance->c1_yb_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_START.Default";

  chartInstance->c1_yb_SignalExportProp.useCustomName = 0;

  chartInstance->c1_yb_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_yb_SignalExportProp.decimate = 0;

  chartInstance->c1_yb_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_yb_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[50U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_START.Default",

      "GEARSHIFT/DOWNSHIFTING/DOWN_START/Default", 1,

      &chartInstance->c1_yb_SignalExportProp, 406U);

  }



  chartInstance->c1_ac_SignalExportProp.logName = "";

  chartInstance->c1_ac_SignalExportProp.signalName =

    "GEARSHIFT.DOWNSHIFTING.DOWN_START.SettingNeutral";

  chartInstance->c1_ac_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ac_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ac_SignalExportProp.decimate = 0;

  chartInstance->c1_ac_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ac_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[51U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWNSHIFTING.DOWN_START.SettingNeutral",

      "GEARSHIFT/DOWNSHIFTING/DOWN_START/SettingNeutral", 1,

      &chartInstance->c1_ac_SignalExportProp, 399U);

  }



  chartInstance->c1_bc_SignalExportProp.logName = "";

  chartInstance->c1_bc_SignalExportProp.signalName = "GEARSHIFT.DOWN_END";

  chartInstance->c1_bc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_bc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_bc_SignalExportProp.decimate = 0;

  chartInstance->c1_bc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_bc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[52U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.DOWN_END", "GEARSHIFT/DOWN_END", 1,

      &chartInstance->c1_bc_SignalExportProp, 18U);

  }



  chartInstance->c1_cc_SignalExportProp.logName = "";

  chartInstance->c1_cc_SignalExportProp.signalName = "GEARSHIFT.IDLE";

  chartInstance->c1_cc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_cc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_cc_SignalExportProp.decimate = 0;

  chartInstance->c1_cc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_cc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[53U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.IDLE", "GEARSHIFT/IDLE", 1,

      &chartInstance->c1_cc_SignalExportProp, 5U);

  }



  chartInstance->c1_dc_SignalExportProp.logName = "";

  chartInstance->c1_dc_SignalExportProp.signalName = "GEARSHIFT.INIT";

  chartInstance->c1_dc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_dc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_dc_SignalExportProp.decimate = 0;

  chartInstance->c1_dc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_dc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[54U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.INIT", "GEARSHIFT/INIT", 1,

      &chartInstance->c1_dc_SignalExportProp, 7U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[55U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING", "GEARSHIFT/UPSHIFTING", 5, c1_rc, c1_sc, sizeof

      (uint8_T), 1, 693U);

  }



  chartInstance->c1_ec_SignalExportProp.logName = "";

  chartInstance->c1_ec_SignalExportProp.signalName = "GEARSHIFT.UPSHIFTING";

  chartInstance->c1_ec_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ec_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ec_SignalExportProp.decimate = 0;

  chartInstance->c1_ec_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ec_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[55U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING", "GEARSHIFT/UPSHIFTING", 1,

      &chartInstance->c1_ec_SignalExportProp, 693U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[55U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING", "GEARSHIFT/UPSHIFTING", 8, c1_tc, c1_uc, 1, 693U);

  }



  chartInstance->c1_fc_SignalExportProp.logName = "";

  chartInstance->c1_fc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_BRAKE";

  chartInstance->c1_fc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_fc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_fc_SignalExportProp.decimate = 0;

  chartInstance->c1_fc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_fc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[56U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_BRAKE", "GEARSHIFT/UPSHIFTING/UP_BRAKE", 1,

      &chartInstance->c1_fc_SignalExportProp, 12U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[57U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_PUSH", "GEARSHIFT/UPSHIFTING/UP_PUSH", 3, c1_vc,

      c1_wc, sizeof(uint8_T), 1, 10U);

  }



  chartInstance->c1_gc_SignalExportProp.logName = "";

  chartInstance->c1_gc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_PUSH";

  chartInstance->c1_gc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_gc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_gc_SignalExportProp.decimate = 0;

  chartInstance->c1_gc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_gc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[57U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_PUSH", "GEARSHIFT/UPSHIFTING/UP_PUSH", 1,

      &chartInstance->c1_gc_SignalExportProp, 10U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[57U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_PUSH", "GEARSHIFT/UPSHIFTING/UP_PUSH", 3, c1_xc,

      c1_yc, 1, 10U);

  }



  chartInstance->c1_hc_SignalExportProp.logName = "";

  chartInstance->c1_hc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_PUSH.CutOff";

  chartInstance->c1_hc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_hc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_hc_SignalExportProp.decimate = 0;

  chartInstance->c1_hc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_hc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[58U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_PUSH.CutOff",

      "GEARSHIFT/UPSHIFTING/UP_PUSH/CutOff", 1,

      &chartInstance->c1_hc_SignalExportProp, 423U);

  }



  chartInstance->c1_ic_SignalExportProp.logName = "";

  chartInstance->c1_ic_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_PUSH.Default";

  chartInstance->c1_ic_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ic_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ic_SignalExportProp.decimate = 0;

  chartInstance->c1_ic_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ic_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[59U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_PUSH.Default",

      "GEARSHIFT/UPSHIFTING/UP_PUSH/Default", 1,

      &chartInstance->c1_ic_SignalExportProp, 422U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[60U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_REBOUND", "GEARSHIFT/UPSHIFTING/UP_REBOUND", 3,

      c1_ad, c1_bd, sizeof(uint8_T), 1, 11U);

  }



  chartInstance->c1_jc_SignalExportProp.logName = "";

  chartInstance->c1_jc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_REBOUND";

  chartInstance->c1_jc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_jc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_jc_SignalExportProp.decimate = 0;

  chartInstance->c1_jc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_jc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[60U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_REBOUND", "GEARSHIFT/UPSHIFTING/UP_REBOUND", 1,

      &chartInstance->c1_jc_SignalExportProp, 11U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[60U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_REBOUND", "GEARSHIFT/UPSHIFTING/UP_REBOUND", 3,

      c1_cd, c1_dd, 1, 11U);

  }



  chartInstance->c1_kc_SignalExportProp.logName = "";

  chartInstance->c1_kc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_REBOUND.Default";

  chartInstance->c1_kc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_kc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_kc_SignalExportProp.decimate = 0;

  chartInstance->c1_kc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_kc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[61U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_REBOUND.Default",

      "GEARSHIFT/UPSHIFTING/UP_REBOUND/Default", 1,

      &chartInstance->c1_kc_SignalExportProp, 390U);

  }



  chartInstance->c1_lc_SignalExportProp.logName = "";

  chartInstance->c1_lc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_REBOUND.SettingNeutral";

  chartInstance->c1_lc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_lc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_lc_SignalExportProp.decimate = 0;

  chartInstance->c1_lc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_lc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[62U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_REBOUND.SettingNeutral",

      "GEARSHIFT/UPSHIFTING/UP_REBOUND/SettingNeutral", 1,

      &chartInstance->c1_lc_SignalExportProp, 391U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[63U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_START", "GEARSHIFT/UPSHIFTING/UP_START", 3, c1_ed,

      c1_fd, sizeof(uint8_T), 1, 9U);

  }



  chartInstance->c1_mc_SignalExportProp.logName = "";

  chartInstance->c1_mc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_START";

  chartInstance->c1_mc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_mc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_mc_SignalExportProp.decimate = 0;

  chartInstance->c1_mc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_mc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[63U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_START", "GEARSHIFT/UPSHIFTING/UP_START", 1,

      &chartInstance->c1_mc_SignalExportProp, 9U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[63U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_START", "GEARSHIFT/UPSHIFTING/UP_START", 3, c1_gd,

      c1_hd, 1, 9U);

  }



  chartInstance->c1_nc_SignalExportProp.logName = "";

  chartInstance->c1_nc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_START.Default";

  chartInstance->c1_nc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_nc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_nc_SignalExportProp.decimate = 0;

  chartInstance->c1_nc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_nc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[64U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_START.Default",

      "GEARSHIFT/UPSHIFTING/UP_START/Default", 1,

      &chartInstance->c1_nc_SignalExportProp, 385U);

  }



  chartInstance->c1_oc_SignalExportProp.logName = "";

  chartInstance->c1_oc_SignalExportProp.signalName =

    "GEARSHIFT.UPSHIFTING.UP_START.SettingNeutral";

  chartInstance->c1_oc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_oc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_oc_SignalExportProp.decimate = 0;

  chartInstance->c1_oc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_oc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[65U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UPSHIFTING.UP_START.SettingNeutral",

      "GEARSHIFT/UPSHIFTING/UP_START/SettingNeutral", 1,

      &chartInstance->c1_oc_SignalExportProp, 383U);

  }



  chartInstance->c1_pc_SignalExportProp.logName = "";

  chartInstance->c1_pc_SignalExportProp.signalName = "GEARSHIFT.UP_END";

  chartInstance->c1_pc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_pc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_pc_SignalExportProp.decimate = 0;

  chartInstance->c1_pc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_pc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[66U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "GEARSHIFT.UP_END", "GEARSHIFT/UP_END", 1,

      &chartInstance->c1_pc_SignalExportProp, 13U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[67U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "START_ENGINE", "START_ENGINE", 4, c1_id, c1_jd, sizeof(uint8_T), 1, 479U);

  }



  chartInstance->c1_qc_SignalExportProp.logName = "";

  chartInstance->c1_qc_SignalExportProp.signalName = "START_ENGINE";

  chartInstance->c1_qc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_qc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_qc_SignalExportProp.decimate = 0;

  chartInstance->c1_qc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_qc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[67U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "START_ENGINE", "START_ENGINE", 1, &chartInstance->c1_qc_SignalExportProp,

      479U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[67U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "START_ENGINE", "START_ENGINE", 4, c1_kd, c1_ld, 1, 479U);

  }



  chartInstance->c1_rc_SignalExportProp.logName = "";

  chartInstance->c1_rc_SignalExportProp.signalName = "START_ENGINE.START";

  chartInstance->c1_rc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_rc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_rc_SignalExportProp.decimate = 0;

  chartInstance->c1_rc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_rc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[68U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "START_ENGINE.START", "START_ENGINE/START", 1,

      &chartInstance->c1_rc_SignalExportProp, 482U);

  }



  chartInstance->c1_sc_SignalExportProp.logName = "";

  chartInstance->c1_sc_SignalExportProp.signalName = "START_ENGINE.STOP";

  chartInstance->c1_sc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_sc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_sc_SignalExportProp.decimate = 0;

  chartInstance->c1_sc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_sc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[69U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "START_ENGINE.STOP", "START_ENGINE/STOP", 1,

      &chartInstance->c1_sc_SignalExportProp, 483U);

  }



  chartInstance->c1_tc_SignalExportProp.logName = "";

  chartInstance->c1_tc_SignalExportProp.signalName = "START_ENGINE.WAIT";

  chartInstance->c1_tc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_tc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_tc_SignalExportProp.decimate = 0;

  chartInstance->c1_tc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_tc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[70U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "START_ENGINE.WAIT", "START_ENGINE/WAIT", 1,

      &chartInstance->c1_tc_SignalExportProp, 494U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[71U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "SCAN_ADC", "SCAN_ADC", 2, c1_md, c1_nd, sizeof(uint8_T), 1, 929U);

  }



  chartInstance->c1_uc_SignalExportProp.logName = "";

  chartInstance->c1_uc_SignalExportProp.signalName = "SCAN_ADC";

  chartInstance->c1_uc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_uc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_uc_SignalExportProp.decimate = 0;

  chartInstance->c1_uc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_uc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[71U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "SCAN_ADC", "SCAN_ADC", 1, &chartInstance->c1_uc_SignalExportProp, 929U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[71U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "SCAN_ADC", "SCAN_ADC", 2, c1_od, c1_pd, 1, 929U);

  }



  chartInstance->c1_vc_SignalExportProp.logName = "";

  chartInstance->c1_vc_SignalExportProp.signalName = "SCAN_ADC.SCAN";

  chartInstance->c1_vc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_vc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_vc_SignalExportProp.decimate = 0;

  chartInstance->c1_vc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_vc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[72U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "SCAN_ADC.SCAN", "SCAN_ADC/SCAN", 1,

      &chartInstance->c1_vc_SignalExportProp, 932U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[73U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "EEPROM_TRIGGER", "EEPROM_TRIGGER", 3, c1_qd, c1_rd, sizeof(uint8_T), 1,

      940U);

  }



  chartInstance->c1_wc_SignalExportProp.logName = "";

  chartInstance->c1_wc_SignalExportProp.signalName = "EEPROM_TRIGGER";

  chartInstance->c1_wc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_wc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_wc_SignalExportProp.decimate = 0;

  chartInstance->c1_wc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_wc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[73U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "EEPROM_TRIGGER", "EEPROM_TRIGGER", 1,

      &chartInstance->c1_wc_SignalExportProp, 940U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[73U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "EEPROM_TRIGGER", "EEPROM_TRIGGER", 3, c1_sd, c1_td, 1, 940U);

  }



  chartInstance->c1_xc_SignalExportProp.logName = "";

  chartInstance->c1_xc_SignalExportProp.signalName = "EEPROM_TRIGGER.SEND";

  chartInstance->c1_xc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_xc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_xc_SignalExportProp.decimate = 0;

  chartInstance->c1_xc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_xc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[74U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "EEPROM_TRIGGER.SEND", "EEPROM_TRIGGER/SEND", 1,

      &chartInstance->c1_xc_SignalExportProp, 946U);

  }



  chartInstance->c1_yc_SignalExportProp.logName = "";

  chartInstance->c1_yc_SignalExportProp.signalName = "EEPROM_TRIGGER.WAIT";

  chartInstance->c1_yc_SignalExportProp.useCustomName = 0;

  chartInstance->c1_yc_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_yc_SignalExportProp.decimate = 0;

  chartInstance->c1_yc_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_yc_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[75U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "EEPROM_TRIGGER.WAIT", "EEPROM_TRIGGER/WAIT", 1,

      &chartInstance->c1_yc_SignalExportProp, 944U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[76U] & 1) {

    sdi_register_child_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "ANTISTALL_ENABLE", "ANTISTALL_ENABLE", 3, c1_ud, c1_vd, sizeof(uint8_T),

      1, 1069U);

  }



  chartInstance->c1_ad_SignalExportProp.logName = "";

  chartInstance->c1_ad_SignalExportProp.signalName = "ANTISTALL_ENABLE";

  chartInstance->c1_ad_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ad_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ad_SignalExportProp.decimate = 0;

  chartInstance->c1_ad_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ad_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[76U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "ANTISTALL_ENABLE", "ANTISTALL_ENABLE", 1,

      &chartInstance->c1_ad_SignalExportProp, 1069U);

  }



  if (chartInstance->c1_sdiLoggedStatesBuffer[76U] & 2) {

    sdi_register_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "ANTISTALL_ENABLE", "ANTISTALL_ENABLE", 3, c1_wd, c1_xd, 1, 1069U);

  }



  chartInstance->c1_bd_SignalExportProp.logName = "";

  chartInstance->c1_bd_SignalExportProp.signalName = "ANTISTALL_ENABLE.DISABLE";

  chartInstance->c1_bd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_bd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_bd_SignalExportProp.decimate = 0;

  chartInstance->c1_bd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_bd_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[77U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "ANTISTALL_ENABLE.DISABLE", "ANTISTALL_ENABLE/DISABLE", 1,

      &chartInstance->c1_bd_SignalExportProp, 1070U);

  }



  chartInstance->c1_cd_SignalExportProp.logName = "";

  chartInstance->c1_cd_SignalExportProp.signalName = "ANTISTALL_ENABLE.ENABLE";

  chartInstance->c1_cd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_cd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_cd_SignalExportProp.decimate = 0;

  chartInstance->c1_cd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_cd_SignalExportProp.decimation = 2U;

  if (chartInstance->c1_sdiLoggedStatesBuffer[78U] & 4) {

    sdi_register_self_activity_signal(&chartInstance->c1_sdiBlockInfo,

      "ANTISTALL_ENABLE.ENABLE", "ANTISTALL_ENABLE/ENABLE", 1,

      &chartInstance->c1_cd_SignalExportProp, 1072U);

  }



  chartInstance->c1_dd_SignalExportProp.logName = "";

  chartInstance->c1_dd_SignalExportProp.signalName = "clutchCurrVal";

  chartInstance->c1_dd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_dd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_dd_SignalExportProp.decimate = 0;

  chartInstance->c1_dd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_dd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[0U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "clutchCurrVal", "", 1, c1_yd, 1, 3, 0, 0,

      &chartInstance->c1_dd_SignalExportProp, "", 123U);

  }



  chartInstance->c1_ed_SignalExportProp.logName = "";

  chartInstance->c1_ed_SignalExportProp.signalName = "lastModeCom";

  chartInstance->c1_ed_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ed_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ed_SignalExportProp.decimate = 0;

  chartInstance->c1_ed_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ed_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[1U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastModeCom", "", 1, c1_ae, 1, 5, 0, 0,

      &chartInstance->c1_ed_SignalExportProp, "", 834U);

  }



  chartInstance->c1_fd_SignalExportProp.logName = "";

  chartInstance->c1_fd_SignalExportProp.signalName = "lastShift";

  chartInstance->c1_fd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_fd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_fd_SignalExportProp.decimate = 0;

  chartInstance->c1_fd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_fd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[6U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastShift", "", 1, c1_be, 1, 3, 0, 0,

      &chartInstance->c1_fd_SignalExportProp, "", 715U);

  }



  chartInstance->c1_gd_SignalExportProp.logName = "";

  chartInstance->c1_gd_SignalExportProp.signalName = "stateFb";

  chartInstance->c1_gd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_gd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_gd_SignalExportProp.decimate = 0;

  chartInstance->c1_gd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_gd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[8U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "stateFb", "", 1, c1_ce, 1, 5, 0, 0,

      &chartInstance->c1_gd_SignalExportProp, "", 833U);

  }



  chartInstance->c1_hd_SignalExportProp.logName = "";

  chartInstance->c1_hd_SignalExportProp.signalName = "antiStallEnable";

  chartInstance->c1_hd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_hd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_hd_SignalExportProp.decimate = 0;

  chartInstance->c1_hd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_hd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[14U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "antiStallEnable", "", 1, c1_de, 1, 3, 0, 0,

      &chartInstance->c1_hd_SignalExportProp, "", 1073U);

  }



  chartInstance->c1_id_SignalExportProp.logName = "";

  chartInstance->c1_id_SignalExportProp.signalName = "pidCounter";

  chartInstance->c1_id_SignalExportProp.useCustomName = 0;

  chartInstance->c1_id_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_id_SignalExportProp.decimate = 0;

  chartInstance->c1_id_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_id_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[25U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "pidCounter", "", 1, c1_ee, 1, 7, 0, 0,

      &chartInstance->c1_id_SignalExportProp, "", 1839U);

  }



  chartInstance->c1_jd_SignalExportProp.logName = "";

  chartInstance->c1_jd_SignalExportProp.signalName = "lastTryShift";

  chartInstance->c1_jd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_jd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_jd_SignalExportProp.decimate = 0;

  chartInstance->c1_jd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_jd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[29U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastTryShift", "", 2, c1_fe, 1, 5, 0, 0,

      &chartInstance->c1_jd_SignalExportProp, "", 2004U);

  }



  chartInstance->c1_kd_SignalExportProp.logName = "";

  chartInstance->c1_kd_SignalExportProp.signalName = "rpmAccTarget";

  chartInstance->c1_kd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_kd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_kd_SignalExportProp.decimate = 0;

  chartInstance->c1_kd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_kd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[30U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "rpmAccTarget", "", 1, c1_ge, 1, 5, 0, 0,

      &chartInstance->c1_kd_SignalExportProp, "", 2851U);

  }



  chartInstance->c1_ld_SignalExportProp.logName = "";

  chartInstance->c1_ld_SignalExportProp.signalName = "lastAacCom";

  chartInstance->c1_ld_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ld_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ld_SignalExportProp.decimate = 0;

  chartInstance->c1_ld_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ld_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[31U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastAacCom", "MODES", 1, c1_he, 1, 5, 0, 0,

      &chartInstance->c1_ld_SignalExportProp, "", 627U);

  }



  chartInstance->c1_md_SignalExportProp.logName = "";

  chartInstance->c1_md_SignalExportProp.signalName = "lastShiftCom";

  chartInstance->c1_md_SignalExportProp.useCustomName = 0;

  chartInstance->c1_md_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_md_SignalExportProp.decimate = 0;

  chartInstance->c1_md_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_md_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[32U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastShiftCom", "MODES", 1, c1_ie, 1, 5, 0, 0,

      &chartInstance->c1_md_SignalExportProp, "", 681U);

  }



  chartInstance->c1_nd_SignalExportProp.logName = "";

  chartInstance->c1_nd_SignalExportProp.signalName = "lastAutoXCom";

  chartInstance->c1_nd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_nd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_nd_SignalExportProp.decimate = 0;

  chartInstance->c1_nd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_nd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[33U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastAutoXCom", "MODES", 1, c1_je, 1, 5, 0, 0,

      &chartInstance->c1_nd_SignalExportProp, "", 1043U);

  }



  chartInstance->c1_od_SignalExportProp.logName = "";

  chartInstance->c1_od_SignalExportProp.signalName = "buzzerCounter";

  chartInstance->c1_od_SignalExportProp.useCustomName = 0;

  chartInstance->c1_od_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_od_SignalExportProp.decimate = 0;

  chartInstance->c1_od_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_od_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[34U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "buzzerCounter", "MODES", 1, c1_ke, 1, 5, 0, 0,

      &chartInstance->c1_od_SignalExportProp, "", 1063U);

  }



  chartInstance->c1_pd_SignalExportProp.logName = "";

  chartInstance->c1_pd_SignalExportProp.signalName = "aacCounter";

  chartInstance->c1_pd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_pd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_pd_SignalExportProp.decimate = 0;

  chartInstance->c1_pd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_pd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[44U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "aacCounter", "MODES/ACCELERATION/ACC", 1, c1_le, 1, 5, 0, 0,

      &chartInstance->c1_pd_SignalExportProp, "", 550U);

  }



  chartInstance->c1_qd_SignalExportProp.logName = "";

  chartInstance->c1_qd_SignalExportProp.signalName = "aac_clutchValue";

  chartInstance->c1_qd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_qd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_qd_SignalExportProp.decimate = 0;

  chartInstance->c1_qd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_qd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[45U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "aac_clutchValue", "MODES/ACCELERATION/ACC", 1, c1_me, 1, 0, 0, 0,

      &chartInstance->c1_qd_SignalExportProp, "", 561U);

  }



  chartInstance->c1_rd_SignalExportProp.logName = "";

  chartInstance->c1_rd_SignalExportProp.signalName = "aac_clutchStep";

  chartInstance->c1_rd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_rd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_rd_SignalExportProp.decimate = 0;

  chartInstance->c1_rd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_rd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[46U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "aac_clutchStep", "MODES/ACCELERATION/ACC", 1, c1_ne, 1, 0, 0, 0,

      &chartInstance->c1_rd_SignalExportProp, "", 563U);

  }



  chartInstance->c1_sd_SignalExportProp.logName = "";

  chartInstance->c1_sd_SignalExportProp.signalName = "aac_dtRelease";

  chartInstance->c1_sd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_sd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_sd_SignalExportProp.decimate = 0;

  chartInstance->c1_sd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_sd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[47U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "aac_dtRelease", "MODES/ACCELERATION/ACC", 1, c1_oe, 1, 6, 0, 0,

      &chartInstance->c1_sd_SignalExportProp, "", 564U);

  }



  chartInstance->c1_td_SignalExportProp.logName = "";

  chartInstance->c1_td_SignalExportProp.signalName = "autoXCounter";

  chartInstance->c1_td_SignalExportProp.useCustomName = 0;

  chartInstance->c1_td_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_td_SignalExportProp.decimate = 0;

  chartInstance->c1_td_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_td_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[63U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoXCounter", "MODES/AUTOCROSS/LAUNCH", 1, c1_pe, 1, 5, 0, 0,

      &chartInstance->c1_td_SignalExportProp, "", 958U);

  }



  chartInstance->c1_ud_SignalExportProp.logName = "";

  chartInstance->c1_ud_SignalExportProp.signalName = "autoX_clutchValue";

  chartInstance->c1_ud_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ud_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ud_SignalExportProp.decimate = 0;

  chartInstance->c1_ud_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ud_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[64U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoX_clutchValue", "MODES/AUTOCROSS/LAUNCH", 1, c1_qe, 1, 0, 0, 0,

      &chartInstance->c1_ud_SignalExportProp, "", 959U);

  }



  chartInstance->c1_vd_SignalExportProp.logName = "";

  chartInstance->c1_vd_SignalExportProp.signalName = "autoX_clutchStep";

  chartInstance->c1_vd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_vd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_vd_SignalExportProp.decimate = 0;

  chartInstance->c1_vd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_vd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[65U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoX_clutchStep", "MODES/AUTOCROSS/LAUNCH", 1, c1_re, 1, 0, 0, 0,

      &chartInstance->c1_vd_SignalExportProp, "", 960U);

  }



  chartInstance->c1_wd_SignalExportProp.logName = "";

  chartInstance->c1_wd_SignalExportProp.signalName = "autoX_dtRelease";

  chartInstance->c1_wd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_wd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_wd_SignalExportProp.decimate = 0;

  chartInstance->c1_wd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_wd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[66U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoX_dtRelease", "MODES/AUTOCROSS/LAUNCH", 1, c1_se, 1, 6, 0, 0,

      &chartInstance->c1_wd_SignalExportProp, "", 961U);

  }



  chartInstance->c1_xd_SignalExportProp.logName = "";

  chartInstance->c1_xd_SignalExportProp.signalName = "autoXCounter";

  chartInstance->c1_xd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_xd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_xd_SignalExportProp.decimate = 0;

  chartInstance->c1_xd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_xd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[70U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoXCounter", "MODES/ACCELERATION_PID/LAUNCH0", 1, c1_te, 1, 5, 0, 0,

      &chartInstance->c1_xd_SignalExportProp, "", 2170U);

  }



  chartInstance->c1_yd_SignalExportProp.logName = "";

  chartInstance->c1_yd_SignalExportProp.signalName = "autoX_clutchValue";

  chartInstance->c1_yd_SignalExportProp.useCustomName = 0;

  chartInstance->c1_yd_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_yd_SignalExportProp.decimate = 0;

  chartInstance->c1_yd_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_yd_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[71U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoX_clutchValue", "MODES/ACCELERATION_PID/LAUNCH0", 1, c1_ue, 1, 0, 0,

      0, &chartInstance->c1_yd_SignalExportProp, "", 2171U);

  }



  chartInstance->c1_ae_SignalExportProp.logName = "";

  chartInstance->c1_ae_SignalExportProp.signalName = "autoX_clutchStep";

  chartInstance->c1_ae_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ae_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ae_SignalExportProp.decimate = 0;

  chartInstance->c1_ae_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ae_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[72U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoX_clutchStep", "MODES/ACCELERATION_PID/LAUNCH0", 1, c1_ve, 1, 0, 0, 0,

      &chartInstance->c1_ae_SignalExportProp, "", 2172U);

  }



  chartInstance->c1_be_SignalExportProp.logName = "";

  chartInstance->c1_be_SignalExportProp.signalName = "autoX_dtRelease";

  chartInstance->c1_be_SignalExportProp.useCustomName = 0;

  chartInstance->c1_be_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_be_SignalExportProp.decimate = 0;

  chartInstance->c1_be_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_be_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[73U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "autoX_dtRelease", "MODES/ACCELERATION_PID/LAUNCH0", 1, c1_we, 1, 6, 0, 0,

      &chartInstance->c1_be_SignalExportProp, "", 2173U);

  }



  chartInstance->c1_ce_SignalExportProp.logName = "";

  chartInstance->c1_ce_SignalExportProp.signalName = "ticksCounter";

  chartInstance->c1_ce_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ce_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ce_SignalExportProp.decimate = 0;

  chartInstance->c1_ce_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ce_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[77U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "ticksCounter", "GEARSHIFT", 1, c1_xe, 1, 6, 0, 0,

      &chartInstance->c1_ce_SignalExportProp, "", 45U);

  }



  chartInstance->c1_de_SignalExportProp.logName = "";

  chartInstance->c1_de_SignalExportProp.signalName = "counterWait";

  chartInstance->c1_de_SignalExportProp.useCustomName = 0;

  chartInstance->c1_de_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_de_SignalExportProp.decimate = 0;

  chartInstance->c1_de_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_de_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[84U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "counterWait", "EEPROM_TRIGGER", 1, c1_ye, 1, 0, 0, 0,

      &chartInstance->c1_de_SignalExportProp, "", 950U);

  }



  chartInstance->c1_ee_SignalExportProp.logName = "";

  chartInstance->c1_ee_SignalExportProp.signalName = "lastCom";

  chartInstance->c1_ee_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ee_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ee_SignalExportProp.decimate = 0;

  chartInstance->c1_ee_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ee_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[85U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "lastCom", "START_ENGINE", 1, c1_af, 1, 3, 0, 0,

      &chartInstance->c1_ee_SignalExportProp, "", 484U);

  }



  chartInstance->c1_fe_SignalExportProp.logName = "";

  chartInstance->c1_fe_SignalExportProp.signalName = "startCounter";

  chartInstance->c1_fe_SignalExportProp.useCustomName = 0;

  chartInstance->c1_fe_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_fe_SignalExportProp.decimate = 0;

  chartInstance->c1_fe_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_fe_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[86U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "startCounter", "START_ENGINE", 1, c1_bf, 1, 3, 0, 0,

      &chartInstance->c1_fe_SignalExportProp, "", 488U);

  }



  chartInstance->c1_ge_SignalExportProp.logName = "";

  chartInstance->c1_ge_SignalExportProp.signalName = "timerCounter";

  chartInstance->c1_ge_SignalExportProp.useCustomName = 0;

  chartInstance->c1_ge_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_ge_SignalExportProp.decimate = 0;

  chartInstance->c1_ge_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_ge_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[87U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "timerCounter", "SCAN_ADC", 1, c1_cf, 1, 5, 0, 0,

      &chartInstance->c1_ge_SignalExportProp, "", 938U);

  }



  chartInstance->c1_he_SignalExportProp.logName = "";

  chartInstance->c1_he_SignalExportProp.signalName = "counterWait";

  chartInstance->c1_he_SignalExportProp.useCustomName = 0;

  chartInstance->c1_he_SignalExportProp.limitDataPoints = 0;

  chartInstance->c1_he_SignalExportProp.decimate = 0;

  chartInstance->c1_he_SignalExportProp.maxPoints = 5000U;

  chartInstance->c1_he_SignalExportProp.decimation = 1U;

  if (chartInstance->c1_sdiLoggedDataBuffer[88U]) {

    sdi_register_builtin_data_type_signal(&chartInstance->c1_sdiBlockInfo,

      "counterWait", "ANTISTALL_ENABLE", 1, c1_df, 1, 0, 0, 0,

      &chartInstance->c1_he_SignalExportProp, "", 1068U);

  }

}



static void c1_sdiTerminate(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  sdi_database_terminate(&chartInstance->c1_sdiBlockInfo);

}



static void initialize_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  int32_T c1_i0;

  int32_T c1_i1;

  int32_T c1_i2;

  int32_T c1_i3;

  if (sf_is_first_init_cond(chartInstance->S)) {

    initSimStructsc1_GCU_Model_genCode(chartInstance);

    chart_debug_initialize_data_addresses(chartInstance->S);

  }



  chartInstance->c1_sfEvent = CALL_EVENT;

  _sfTime_ = sf_get_time(chartInstance->S);

  chartInstance->c1_doSetSimStateSideEffects = 0U;

  chartInstance->c1_setSimStateSideEffectsInfo = NULL;

  chartInstance->c1_is_active_ANTISTALL_ENABLE = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 76, 1069U, (int32_T)

    (chartInstance->c1_is_active_ANTISTALL_ENABLE == 1));

  chartInstance->c1_is_ANTISTALL_ENABLE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 76, 1069U, (void *)

    &chartInstance->c1_is_ANTISTALL_ENABLE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 77, 1070U, (int32_T)

    (chartInstance->c1_is_ANTISTALL_ENABLE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 78, 1072U, (int32_T)

    (chartInstance->c1_is_ANTISTALL_ENABLE == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 76, 1069U, 0);

  chartInstance->c1_tp_ANTISTALL_ENABLE = 0U;

  chartInstance->c1_tp_DISABLE = 0U;

  chartInstance->c1_tp_ENABLE = 0U;

  chartInstance->c1_is_active_EEPROM_TRIGGER = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 73, 940U, (int32_T)

    (chartInstance->c1_is_active_EEPROM_TRIGGER == 1));

  chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 73, 940U, (void *)

    &chartInstance->c1_is_EEPROM_TRIGGER);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

    (chartInstance->c1_is_EEPROM_TRIGGER == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

    (chartInstance->c1_is_EEPROM_TRIGGER == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 73, 940U, 0);

  chartInstance->c1_tp_EEPROM_TRIGGER = 0U;

  chartInstance->c1_tp_SEND = 0U;

  chartInstance->c1_tp_WAIT = 0U;

  chartInstance->c1_is_active_GEARSHIFT = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 41, 1U, (int32_T)

    (chartInstance->c1_is_active_GEARSHIFT == 1));

  chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

    &chartInstance->c1_is_GEARSHIFT);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 5));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 6));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  chartInstance->c1_tp_GEARSHIFT = 0U;

  chartInstance->c1_is_DOWNSHIFTING = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

    &chartInstance->c1_is_DOWNSHIFTING);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 4));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 0);

  chartInstance->c1_tp_DOWNSHIFTING = 0U;

  chartInstance->c1_is_DOWN_BRAKE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 43, 17U, (void *)

    &chartInstance->c1_is_DOWN_BRAKE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

    (chartInstance->c1_is_DOWN_BRAKE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

    (chartInstance->c1_is_DOWN_BRAKE == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 43, 17U, 0);

  chartInstance->c1_tp_DOWN_BRAKE = 0U;

  chartInstance->c1_b_tp_ChangeClutch = 0U;

  chartInstance->c1_e_tp_Default = 0U;

  chartInstance->c1_tp_DOWN_PUSH = 0U;

  chartInstance->c1_tp_DOWN_REBOUND = 0U;

  chartInstance->c1_is_DOWN_START = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 48, 14U, (void *)

    &chartInstance->c1_is_DOWN_START);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

    (chartInstance->c1_is_DOWN_START == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

    (chartInstance->c1_is_DOWN_START == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

    (chartInstance->c1_is_DOWN_START == 3));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 48, 14U, 0);

  chartInstance->c1_tp_DOWN_START = 0U;

  chartInstance->c1_tp_ChangeClutch = 0U;

  chartInstance->c1_d_tp_Default = 0U;

  chartInstance->c1_c_tp_SettingNeutral = 0U;

  chartInstance->c1_tp_DOWN_END = 0U;

  chartInstance->c1_tp_IDLE = 0U;

  chartInstance->c1_b_tp_INIT = 0U;

  chartInstance->c1_is_UPSHIFTING = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

    &chartInstance->c1_is_UPSHIFTING);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 4));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 0);

  chartInstance->c1_tp_UPSHIFTING = 0U;

  chartInstance->c1_tp_UP_BRAKE = 0U;

  chartInstance->c1_is_UP_PUSH = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 57, 10U, (void *)

    &chartInstance->c1_is_UP_PUSH);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

    (chartInstance->c1_is_UP_PUSH == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

    (chartInstance->c1_is_UP_PUSH == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 57, 10U, 0);

  chartInstance->c1_tp_UP_PUSH = 0U;

  chartInstance->c1_tp_CutOff = 0U;

  chartInstance->c1_b_tp_Default = 0U;

  chartInstance->c1_is_UP_REBOUND = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 60, 11U, (void *)

    &chartInstance->c1_is_UP_REBOUND);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

    (chartInstance->c1_is_UP_REBOUND == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

    (chartInstance->c1_is_UP_REBOUND == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 60, 11U, 0);

  chartInstance->c1_tp_UP_REBOUND = 0U;

  chartInstance->c1_tp_Default = 0U;

  chartInstance->c1_tp_SettingNeutral = 0U;

  chartInstance->c1_is_UP_START = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 63, 9U, (void *)

    &chartInstance->c1_is_UP_START);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

    (chartInstance->c1_is_UP_START == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

    (chartInstance->c1_is_UP_START == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 63, 9U, 0);

  chartInstance->c1_tp_UP_START = 0U;

  chartInstance->c1_c_tp_Default = 0U;

  chartInstance->c1_b_tp_SettingNeutral = 0U;

  chartInstance->c1_tp_UP_END = 0U;

  chartInstance->c1_is_active_MODES = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 1, 418U, (int32_T)

    (chartInstance->c1_is_active_MODES == 1));

  chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

    &chartInstance->c1_is_MODES);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

    (chartInstance->c1_is_MODES == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

    (chartInstance->c1_is_MODES == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

    (chartInstance->c1_is_MODES == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

    (chartInstance->c1_is_MODES == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

    (chartInstance->c1_is_MODES == 5));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  chartInstance->c1_tp_MODES = 0U;

  chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

    &chartInstance->c1_is_ACCELERATION);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

    (chartInstance->c1_is_ACCELERATION == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

    (chartInstance->c1_is_ACCELERATION == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

  chartInstance->c1_tp_ACCELERATION = 0U;

  chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

    &chartInstance->c1_is_ACC);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

    (chartInstance->c1_is_ACC == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

    (chartInstance->c1_is_ACC == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 0);

  chartInstance->c1_tp_ACC = 0U;

  chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

    &chartInstance->c1_is_ACTIVE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 5));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 0);

  chartInstance->c1_tp_ACTIVE = 0U;

  chartInstance->c1_tp_READY = 0U;

  chartInstance->c1_tp_RELEASING = 0U;

  chartInstance->c1_tp_RUNNING = 0U;

  chartInstance->c1_tp_START = 0U;

  chartInstance->c1_tp_START_RELEASE = 0U;

  chartInstance->c1_tp_STOPPING = 0U;

  chartInstance->c1_tp_DEFAULT = 0U;

  chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

    &chartInstance->c1_is_ACCELERATION_PID);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

    (chartInstance->c1_is_ACCELERATION_PID == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

    (chartInstance->c1_is_ACCELERATION_PID == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

  chartInstance->c1_tp_ACCELERATION_PID = 0U;

  chartInstance->c1_c_tp_DEFAULT = 0U;

  chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

    &chartInstance->c1_is_LAUNCH0);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

    (chartInstance->c1_is_LAUNCH0 == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

    (chartInstance->c1_is_LAUNCH0 == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 0);

  chartInstance->c1_tp_LAUNCH0 = 0U;

  chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

    &chartInstance->c1_c_is_ACTIVE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 5));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 0);

  chartInstance->c1_c_tp_ACTIVE = 0U;

  chartInstance->c1_c_tp_READY = 0U;

  chartInstance->c1_tp_RELEASE = 0U;

  chartInstance->c1_tp_RPM_LIMITER = 0U;

  chartInstance->c1_c_tp_RUNNING = 0U;

  chartInstance->c1_c_tp_START = 0U;

  chartInstance->c1_c_tp_STOPPING = 0U;

  chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

    &chartInstance->c1_is_AUTOCROSS);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

    (chartInstance->c1_is_AUTOCROSS == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

    (chartInstance->c1_is_AUTOCROSS == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

  chartInstance->c1_tp_AUTOCROSS = 0U;

  chartInstance->c1_b_tp_DEFAULT = 0U;

  chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

    &chartInstance->c1_is_LAUNCH);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

    (chartInstance->c1_is_LAUNCH == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

    (chartInstance->c1_is_LAUNCH == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 0);

  chartInstance->c1_tp_LAUNCH = 0U;

  chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

    &chartInstance->c1_b_is_ACTIVE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 5));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 0);

  chartInstance->c1_b_tp_ACTIVE = 0U;

  chartInstance->c1_b_tp_READY = 0U;

  chartInstance->c1_b_tp_RELEASING = 0U;

  chartInstance->c1_b_tp_RUNNING = 0U;

  chartInstance->c1_b_tp_START = 0U;

  chartInstance->c1_b_tp_START_RELEASE = 0U;

  chartInstance->c1_b_tp_STOPPING = 0U;

  chartInstance->c1_tp_INIT = 0U;

  chartInstance->c1_is_MANUAL_MODES = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

    &chartInstance->c1_is_MANUAL_MODES);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

    (chartInstance->c1_is_MANUAL_MODES == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

    (chartInstance->c1_is_MANUAL_MODES == 2));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 0);

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 0);

  chartInstance->c1_tp_MANUAL_MODES = 0U;

  chartInstance->c1_tp_ENDURANCE = 0U;

  chartInstance->c1_tp_SKIDPAD = 0U;

  chartInstance->c1_is_active_NEUTRAL_STATE = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 36, 31U, (int32_T)

    (chartInstance->c1_is_active_NEUTRAL_STATE == 1));

  chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

    &chartInstance->c1_is_NEUTRAL_STATE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 4));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 0);

  chartInstance->c1_tp_NEUTRAL_STATE = 0U;

  chartInstance->c1_tp_NEUTRAL = 0U;

  chartInstance->c1_tp_NO_NEUTRAL = 0U;

  chartInstance->c1_tp_SET_NEUTRAL = 0U;

  chartInstance->c1_tp_UNSET_NEUTRAL = 0U;

  chartInstance->c1_is_active_SCAN_ADC = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 71, 929U, (int32_T)

    (chartInstance->c1_is_active_SCAN_ADC == 1));

  chartInstance->c1_is_SCAN_ADC = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 71, 929U, (void *)

    &chartInstance->c1_is_SCAN_ADC);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 72, 932U, (int32_T)

    (chartInstance->c1_is_SCAN_ADC == 1));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 71, 929U, 0);

  chartInstance->c1_tp_SCAN_ADC = 0U;

  chartInstance->c1_tp_SCAN = 0U;

  chartInstance->c1_is_active_START_ENGINE = 0U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 67, 479U, (int32_T)

    (chartInstance->c1_is_active_START_ENGINE == 1));

  chartInstance->c1_is_START_ENGINE = c1_IN_NO_ACTIVE_CHILD;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

    &chartInstance->c1_is_START_ENGINE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 3));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 67, 479U, 0);

  chartInstance->c1_tp_START_ENGINE = 0U;

  chartInstance->c1_d_tp_START = 0U;

  chartInstance->c1_tp_STOP = 0U;

  chartInstance->c1_b_tp_WAIT = 0U;

  chartInstance->c1_is_active_c1_GCU_Model_genCode = 0U;

  chartInstance->c1_lastShift = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

    &chartInstance->c1_lastShift);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

  chartInstance->c1_lastTryShift[0] = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

    &chartInstance->c1_lastTryShift);

  for (c1_i0 = 0; c1_i0 < 2; c1_i0++) {

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i0], 23U);

  }



  chartInstance->c1_lastTryShift[1] = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

    &chartInstance->c1_lastTryShift);

  for (c1_i1 = 0; c1_i1 < 2; c1_i1++) {

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i1], 23U);

  }



  chartInstance->c1_lastAacCom = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

  chartInstance->c1_lastShiftCom = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShiftCom, 3U);

  chartInstance->c1_lastAutoXCom = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

  chartInstance->c1_buzzerCounter = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_buzzerCounter, 0U);

  chartInstance->c1_aacCounter = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

  chartInstance->c1_aac_clutchValue = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchValue, 6U);

  chartInstance->c1_aac_clutchStep = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchStep, 5U);

  chartInstance->c1_aac_dtRelease = 0;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aac_dtRelease, 7U);

  chartInstance->c1_autoXCounter = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

  chartInstance->c1_autoX_clutchValue = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchValue, 10U);

  chartInstance->c1_autoX_clutchStep = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchStep, 9U);

  chartInstance->c1_autoX_dtRelease = 0;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoX_dtRelease, 11U);

  chartInstance->c1_b_autoXCounter = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

  chartInstance->c1_b_autoX_clutchValue = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_b_autoX_clutchValue, 14U);

  chartInstance->c1_b_autoX_clutchStep = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_b_autoX_clutchStep, 13U);

  chartInstance->c1_b_autoX_dtRelease = 0;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoX_dtRelease, 15U);

  chartInstance->c1_ticksCounter = 0;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

  chartInstance->c1_counterWait = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_counterWait, 17U);

  chartInstance->c1_lastCom = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastCom, 18U);

  chartInstance->c1_startCounter = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_startCounter, 19U);

  chartInstance->c1_timerCounter = 0U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_timerCounter, 20U);

  chartInstance->c1_b_counterWait = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_b_counterWait, 21U);

  chartInstance->c1_GEAR_COMMAND_NEUTRAL_UP = 50U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_GEAR_COMMAND_NEUTRAL_UP, 55U);

  chartInstance->c1_GEAR_COMMAND_NEUTRAL_DOWN = 100U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_GEAR_COMMAND_NEUTRAL_DOWN, 54U);

  chartInstance->c1_GEAR_COMMAND_UP = 400U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_GEAR_COMMAND_UP, 56U);

  chartInstance->c1_GEAR_COMMAND_DOWN = 200U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_GEAR_COMMAND_DOWN, 53U);

  chartInstance->c1_b_GEAR_COMMAND_NEUTRAL_UP = 50U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_GEAR_COMMAND_NEUTRAL_UP, 59U);

  chartInstance->c1_b_GEAR_COMMAND_NEUTRAL_DOWN = 100U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_GEAR_COMMAND_NEUTRAL_DOWN,

                        58U);

  chartInstance->c1_b_GEAR_COMMAND_UP = 400U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_GEAR_COMMAND_UP, 60U);

  chartInstance->c1_b_GEAR_COMMAND_DOWN = 200U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_GEAR_COMMAND_DOWN, 57U);

  chartInstance->c1_AAC_WORK_RATE_ms = 25U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_AAC_WORK_RATE_ms, 61U);

  chartInstance->c1_DEF_RAMP_START = 50;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RAMP_START, 64U);

  chartInstance->c1_DEF_RAMP_END = 0;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RAMP_END, 63U);

  chartInstance->c1_DEF_RAMP_TIME = 250;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RAMP_TIME, 65U);

  chartInstance->c1_DEF_RPM_LIMIT_1_2 = 11000;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RPM_LIMIT_1_2, 66U);

  chartInstance->c1_DEF_RPM_LIMIT_2_3 = 11000;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RPM_LIMIT_2_3, 67U);

  chartInstance->c1_DEF_RPM_LIMIT_3_4 = 11000;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RPM_LIMIT_3_4, 68U);

  chartInstance->c1_DEF_RPM_LIMIT_4_5 = 11000;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_RPM_LIMIT_4_5, 69U);

  chartInstance->c1_DEF_SPEED_LIMIT_1_2 = 46;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_SPEED_LIMIT_1_2, 70U);

  chartInstance->c1_DEF_SPEED_LIMIT_2_3 = 61;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_SPEED_LIMIT_2_3, 71U);

  chartInstance->c1_DEF_SPEED_LIMIT_3_4 = 77;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_SPEED_LIMIT_3_4, 72U);

  chartInstance->c1_DEF_SPEED_LIMIT_4_5 = 113;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_DEF_SPEED_LIMIT_4_5, 73U);

  chartInstance->c1_ACC_CODE = 1U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ACC_CODE, 62U);

  chartInstance->c1_AUTOX_WORK_RATE_ms = 25U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_AUTOX_WORK_RATE_ms, 74U);

  chartInstance->c1_b_AUTOX_WORK_RATE_ms = 25U;

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_AUTOX_WORK_RATE_ms, 75U);

  chartInstance->c1_data = 0.0;

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_data, 76U);

  if (!(sf_get_output_port_reusable(chartInstance->S, 1) != 0)) {

    *chartInstance->c1_clutchCurrVal = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 0, 123U, (void *)

      chartInstance->c1_clutchCurrVal);

    _SFD_DATA_RANGE_CHECK_MIN_MAX((real_T)*chartInstance->c1_clutchCurrVal, 47U,

      0.0, 100.0, 0U, 0, 0);

  }



  if (!(sf_get_output_port_reusable(chartInstance->S, 2) != 0)) {

    for (c1_i2 = 0; c1_i2 < 2; c1_i2++) {

      (*chartInstance->c1_lastModeCom)[c1_i2] = 0U;

    }



    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

      chartInstance->c1_lastModeCom);

    for (c1_i3 = 0; c1_i3 < 2; c1_i3++) {

      _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i3], 48U);

    }

  }



  if (!(sf_get_output_port_reusable(chartInstance->S, 3) != 0)) {

    *chartInstance->c1_stateFb = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

  }



  if (!(sf_get_output_port_reusable(chartInstance->S, 4) != 0)) {

    *chartInstance->c1_antiStallEnable = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 14, 1073U, (void *)

      chartInstance->c1_antiStallEnable);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_antiStallEnable, 50U);

  }



  if (!(sf_get_output_port_reusable(chartInstance->S, 5) != 0)) {

    *chartInstance->c1_pidCounter = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 25, 1839U, (void *)

      chartInstance->c1_pidCounter);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_pidCounter, 51U);

  }



  if (!(sf_get_output_port_reusable(chartInstance->S, 6) != 0)) {

    *chartInstance->c1_rpmAccTarget = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 30, 2851U, (void *)

      chartInstance->c1_rpmAccTarget);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_rpmAccTarget, 52U);

  }

}



static void initialize_params_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  (void)chartInstance;

}



static void enable_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  _sfTime_ = sf_get_time(chartInstance->S);

  sf_call_output_fcn_enable(chartInstance->S, 0, "Clutch_set", 0);

  sf_call_output_fcn_enable(chartInstance->S, 1, "Efi_init", 0);

  sf_call_output_fcn_enable(chartInstance->S, 2, "Efi_setCut", 0);

  sf_call_output_fcn_enable(chartInstance->S, 3, "Efi_unsetCut", 0);

  sf_call_output_fcn_enable(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

  sf_call_output_fcn_enable(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

  sf_call_output_fcn_enable(chartInstance->S, 6, "Gearshift_rebound", 0);

  sf_call_output_fcn_enable(chartInstance->S, 7, "Gearshift_up_push", 0);

  sf_call_output_fcn_enable(chartInstance->S, 8, "Gearshift_down_push", 0);

  sf_call_output_fcn_enable(chartInstance->S, 9, "Gearshift_brake", 0);

  sf_call_output_fcn_enable(chartInstance->S, 10, "Gearshift_free", 0);

  sf_call_output_fcn_enable(chartInstance->S, 11, "EngineControl_start", 0);

  sf_call_output_fcn_enable(chartInstance->S, 12, "EngineControl_stop", 0);

  sf_call_output_fcn_enable(chartInstance->S, 13, "eepromTrigger", 0);

  sf_call_output_fcn_enable(chartInstance->S, 14, "BuzzerOn", 0);

  sf_call_output_fcn_enable(chartInstance->S, 15, "BuzzerOff", 0);

  if (chartInstance->c1_is_LAUNCH0 == c1_IN_ACTIVE) {

    sf_call_output_fcn_enable(chartInstance->S, 16, "ramp", 0);

  }



  if (chartInstance->c1_is_active_GEARSHIFT == 1U) {

    sf_call_output_fcn_enable(chartInstance->S, 26, "checkCurrent", 0);

  }



  if (chartInstance->c1_is_active_SCAN_ADC == 1U) {

    sf_call_output_fcn_enable(chartInstance->S, 27, "ScanADC", 0);

  }

}



static void disable_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  _sfTime_ = sf_get_time(chartInstance->S);

  sf_call_output_fcn_disable(chartInstance->S, 0, "Clutch_set", 0);

  sf_call_output_fcn_disable(chartInstance->S, 1, "Efi_init", 0);

  sf_call_output_fcn_disable(chartInstance->S, 2, "Efi_setCut", 0);

  sf_call_output_fcn_disable(chartInstance->S, 3, "Efi_unsetCut", 0);

  sf_call_output_fcn_disable(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

  sf_call_output_fcn_disable(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

  sf_call_output_fcn_disable(chartInstance->S, 6, "Gearshift_rebound", 0);

  sf_call_output_fcn_disable(chartInstance->S, 7, "Gearshift_up_push", 0);

  sf_call_output_fcn_disable(chartInstance->S, 8, "Gearshift_down_push", 0);

  sf_call_output_fcn_disable(chartInstance->S, 9, "Gearshift_brake", 0);

  sf_call_output_fcn_disable(chartInstance->S, 10, "Gearshift_free", 0);

  sf_call_output_fcn_disable(chartInstance->S, 11, "EngineControl_start", 0);

  sf_call_output_fcn_disable(chartInstance->S, 12, "EngineControl_stop", 0);

  sf_call_output_fcn_disable(chartInstance->S, 13, "eepromTrigger", 0);

  sf_call_output_fcn_disable(chartInstance->S, 14, "BuzzerOn", 0);

  sf_call_output_fcn_disable(chartInstance->S, 15, "BuzzerOff", 0);

  if (chartInstance->c1_is_LAUNCH0 == c1_IN_ACTIVE) {

    sf_call_output_fcn_disable(chartInstance->S, 16, "ramp", 0);

  }



  if (chartInstance->c1_is_active_GEARSHIFT == 1U) {

    sf_call_output_fcn_disable(chartInstance->S, 26, "checkCurrent", 0);

  }



  if (chartInstance->c1_is_active_SCAN_ADC == 1U) {

    sf_call_output_fcn_disable(chartInstance->S, 27, "ScanADC", 0);

  }

}



static void c1_update_debugger_state_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  uint32_T c1_prevAniVal;

  c1_prevAniVal = _SFD_GET_ANIMATION();

  _SFD_SET_ANIMATION(0U);

  _SFD_SET_HONOR_BREAKPOINTS(0U);

  if (chartInstance->c1_is_active_c1_GCU_Model_genCode == 1U) {

    _SFD_CC_CALL(CHART_ACTIVE_TAG, 0U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_MODES == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 35U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 35U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MANUAL_MODES == c1_IN_ENDURANCE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MODES == c1_IN_INIT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACCELERATION == c1_IN_ACC) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACC == c1_IN_ACTIVE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACTIVE == c1_IN_START) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 42U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 42U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACTIVE == c1_IN_READY) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACTIVE == c1_IN_START_RELEASE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 43U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 43U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACTIVE == c1_IN_RUNNING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 41U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 41U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACTIVE == c1_IN_RELEASING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACC == c1_IN_STOPPING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 45U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 45U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACCELERATION == c1_IN_DEFAULT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 47U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 47U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MODES == c1_IN_AUTOCROSS) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_AUTOCROSS == c1_IN_LAUNCH) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 63U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 63U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_LAUNCH == c1_IN_ACTIVE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_b_is_ACTIVE == c1_IN_START) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 68U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 68U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_b_is_ACTIVE == c1_IN_READY) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_b_is_ACTIVE == c1_IN_START_RELEASE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 69U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 69U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_b_is_ACTIVE == c1_IN_RUNNING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 67U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 67U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_b_is_ACTIVE == c1_IN_RELEASING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_LAUNCH == c1_IN_STOPPING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_AUTOCROSS == c1_b_IN_DEFAULT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACCELERATION_PID == c1_IN_LAUNCH0) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 50U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 50U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_LAUNCH0 == c1_IN_ACTIVE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_c_is_ACTIVE == c1_b_IN_START) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 56U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 56U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_c_is_ACTIVE == c1_IN_READY) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_c_is_ACTIVE == c1_b_IN_RUNNING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 55U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 55U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_c_is_ACTIVE == c1_IN_RELEASE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 53U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 53U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_LAUNCH0 == c1_IN_STOPPING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ACCELERATION_PID == c1_b_IN_DEFAULT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_NEUTRAL_STATE == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 79U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 79U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_NEUTRAL) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_UNSET_NEUTRAL) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 83U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 83U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 82U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 82U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_NO_NEUTRAL) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 81U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 81U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_GEARSHIFT == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 7U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 7U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_GEARSHIFT == c1_IN_UPSHIFTING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 22U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 22U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_REBOUND) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 27U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 27U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UP_REBOUND == c1_IN_Default) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UP_REBOUND == c1_IN_SettingNeutral) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 29U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 29U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_PUSH) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 24U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 24U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UP_PUSH == c1_b_IN_Default) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 26U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 26U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UP_PUSH == c1_IN_CutOff) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_START) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 30U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 30U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UP_START == c1_IN_Default) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UP_START == c1_IN_SettingNeutral) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 32U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 32U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_BRAKE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 23U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 23U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_GEARSHIFT == c1_IN_UP_END) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 33U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 33U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_GEARSHIFT == c1_IN_IDLE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_GEARSHIFT == c1_IN_INIT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 21U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 21U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_GEARSHIFT == c1_IN_DOWNSHIFTING) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 8U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 8U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_START) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 14U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 14U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWN_START == c1_b_IN_SettingNeutral) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 17U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 17U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWN_START == c1_IN_ChangeClutch) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWN_START == c1_b_IN_Default) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 16U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 16U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_BRAKE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 9U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 9U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWN_BRAKE == c1_b_IN_Default) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 11U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 11U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWN_BRAKE == c1_IN_ChangeClutch) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_PUSH) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 12U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 12U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_REBOUND) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 13U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 13U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_GEARSHIFT == c1_IN_DOWN_END) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 18U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 18U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_EEPROM_TRIGGER == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 4U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 4U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_WAIT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 6U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 6U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_SEND) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 5U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 5U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_START_ENGINE == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 87U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 87U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_START_ENGINE == c1_b_IN_WAIT) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 90U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 90U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_START_ENGINE == c1_c_IN_START) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_START_ENGINE == c1_IN_STOP) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 89U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 89U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_SCAN_ADC == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 84U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 84U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_SCAN_ADC == c1_IN_SCAN) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 85U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 85U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_active_ANTISTALL_ENABLE == 1U) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 0U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 0U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ANTISTALL_ENABLE == c1_IN_DISABLE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 1U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 1U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_is_ANTISTALL_ENABLE == c1_IN_ENABLE) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 2U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 2U, chartInstance->c1_sfEvent);

  }



  if (chartInstance->c1_c_is_ACTIVE == c1_IN_RPM_LIMITER) {

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 54U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 54U, chartInstance->c1_sfEvent);

  }



  _SFD_SET_ANIMATION(c1_prevAniVal);

  _SFD_SET_HONOR_BREAKPOINTS(1U);

  _SFD_ANIMATE();

}



static const mxArray *get_sim_state_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  const mxArray *c1_st;

  const mxArray *c1_y = NULL;

  uint8_T c1_hoistedGlobal;

  const mxArray *c1_b_y = NULL;

  uint8_T c1_b_hoistedGlobal;

  const mxArray *c1_c_y = NULL;

  const mxArray *c1_d_y = NULL;

  uint32_T c1_c_hoistedGlobal;

  const mxArray *c1_e_y = NULL;

  uint16_T c1_d_hoistedGlobal;

  const mxArray *c1_f_y = NULL;

  uint16_T c1_e_hoistedGlobal;

  const mxArray *c1_g_y = NULL;

  uint16_T c1_f_hoistedGlobal;

  const mxArray *c1_h_y = NULL;

  real_T c1_g_hoistedGlobal;

  const mxArray *c1_i_y = NULL;

  real_T c1_h_hoistedGlobal;

  const mxArray *c1_j_y = NULL;

  int32_T c1_i_hoistedGlobal;

  const mxArray *c1_k_y = NULL;

  uint16_T c1_j_hoistedGlobal;

  const mxArray *c1_l_y = NULL;

  uint16_T c1_k_hoistedGlobal;

  const mxArray *c1_m_y = NULL;

  real_T c1_l_hoistedGlobal;

  const mxArray *c1_n_y = NULL;

  real_T c1_m_hoistedGlobal;

  const mxArray *c1_o_y = NULL;

  real_T c1_n_hoistedGlobal;

  const mxArray *c1_p_y = NULL;

  real_T c1_o_hoistedGlobal;

  const mxArray *c1_q_y = NULL;

  int32_T c1_p_hoistedGlobal;

  const mxArray *c1_r_y = NULL;

  int32_T c1_q_hoistedGlobal;

  const mxArray *c1_s_y = NULL;

  uint16_T c1_r_hoistedGlobal;

  const mxArray *c1_t_y = NULL;

  real_T c1_s_hoistedGlobal;

  const mxArray *c1_u_y = NULL;

  real_T c1_t_hoistedGlobal;

  const mxArray *c1_v_y = NULL;

  uint16_T c1_u_hoistedGlobal;

  const mxArray *c1_w_y = NULL;

  uint16_T c1_v_hoistedGlobal;

  const mxArray *c1_x_y = NULL;

  uint8_T c1_w_hoistedGlobal;

  const mxArray *c1_y_y = NULL;

  uint8_T c1_x_hoistedGlobal;

  const mxArray *c1_ab_y = NULL;

  uint16_T c1_y_hoistedGlobal;

  const mxArray *c1_bb_y = NULL;

  const mxArray *c1_cb_y = NULL;

  uint8_T c1_ab_hoistedGlobal;

  const mxArray *c1_db_y = NULL;

  int32_T c1_bb_hoistedGlobal;

  const mxArray *c1_eb_y = NULL;

  uint16_T c1_cb_hoistedGlobal;

  const mxArray *c1_fb_y = NULL;

  uint8_T c1_db_hoistedGlobal;

  const mxArray *c1_gb_y = NULL;

  uint8_T c1_eb_hoistedGlobal;

  const mxArray *c1_hb_y = NULL;

  uint8_T c1_fb_hoistedGlobal;

  const mxArray *c1_ib_y = NULL;

  uint8_T c1_gb_hoistedGlobal;

  const mxArray *c1_jb_y = NULL;

  uint8_T c1_hb_hoistedGlobal;

  const mxArray *c1_kb_y = NULL;

  uint8_T c1_ib_hoistedGlobal;

  const mxArray *c1_lb_y = NULL;

  uint8_T c1_jb_hoistedGlobal;

  const mxArray *c1_mb_y = NULL;

  uint8_T c1_kb_hoistedGlobal;

  const mxArray *c1_nb_y = NULL;

  uint8_T c1_lb_hoistedGlobal;

  const mxArray *c1_ob_y = NULL;

  uint8_T c1_mb_hoistedGlobal;

  const mxArray *c1_pb_y = NULL;

  uint8_T c1_nb_hoistedGlobal;

  const mxArray *c1_qb_y = NULL;

  uint8_T c1_ob_hoistedGlobal;

  const mxArray *c1_rb_y = NULL;

  uint8_T c1_pb_hoistedGlobal;

  const mxArray *c1_sb_y = NULL;

  uint8_T c1_qb_hoistedGlobal;

  const mxArray *c1_tb_y = NULL;

  uint8_T c1_rb_hoistedGlobal;

  const mxArray *c1_ub_y = NULL;

  uint8_T c1_sb_hoistedGlobal;

  const mxArray *c1_vb_y = NULL;

  uint8_T c1_tb_hoistedGlobal;

  const mxArray *c1_wb_y = NULL;

  uint8_T c1_ub_hoistedGlobal;

  const mxArray *c1_xb_y = NULL;

  uint8_T c1_vb_hoistedGlobal;

  const mxArray *c1_yb_y = NULL;

  uint8_T c1_wb_hoistedGlobal;

  const mxArray *c1_ac_y = NULL;

  uint8_T c1_xb_hoistedGlobal;

  const mxArray *c1_bc_y = NULL;

  uint8_T c1_yb_hoistedGlobal;

  const mxArray *c1_cc_y = NULL;

  uint8_T c1_ac_hoistedGlobal;

  const mxArray *c1_dc_y = NULL;

  uint8_T c1_bc_hoistedGlobal;

  const mxArray *c1_ec_y = NULL;

  uint8_T c1_cc_hoistedGlobal;

  const mxArray *c1_fc_y = NULL;

  uint8_T c1_dc_hoistedGlobal;

  const mxArray *c1_gc_y = NULL;

  uint8_T c1_ec_hoistedGlobal;

  const mxArray *c1_hc_y = NULL;

  uint8_T c1_fc_hoistedGlobal;

  const mxArray *c1_ic_y = NULL;

  uint8_T c1_gc_hoistedGlobal;

  const mxArray *c1_jc_y = NULL;

  uint8_T c1_hc_hoistedGlobal;

  const mxArray *c1_kc_y = NULL;

  uint8_T c1_ic_hoistedGlobal;

  const mxArray *c1_lc_y = NULL;

  uint8_T c1_jc_hoistedGlobal;

  const mxArray *c1_mc_y = NULL;

  c1_st = NULL;

  c1_st = NULL;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_createcellmatrix(62, 1), false);

  c1_hoistedGlobal = *chartInstance->c1_antiStallEnable;

  c1_b_y = NULL;

  sf_mex_assign(&c1_b_y, sf_mex_create("y", &c1_hoistedGlobal, 3, 0U, 0U, 0U, 0),

                false);

  sf_mex_setcell(c1_y, 0, c1_b_y);

  c1_b_hoistedGlobal = *chartInstance->c1_clutchCurrVal;

  c1_c_y = NULL;

  sf_mex_assign(&c1_c_y, sf_mex_create("y", &c1_b_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 1, c1_c_y);

  c1_d_y = NULL;

  sf_mex_assign(&c1_d_y, sf_mex_create("y", *chartInstance->c1_lastModeCom, 5,

    0U, 1U, 0U, 1, 2), false);

  sf_mex_setcell(c1_y, 2, c1_d_y);

  c1_c_hoistedGlobal = *chartInstance->c1_pidCounter;

  c1_e_y = NULL;

  sf_mex_assign(&c1_e_y, sf_mex_create("y", &c1_c_hoistedGlobal, 7, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 3, c1_e_y);

  c1_d_hoistedGlobal = *chartInstance->c1_rpmAccTarget;

  c1_f_y = NULL;

  sf_mex_assign(&c1_f_y, sf_mex_create("y", &c1_d_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 4, c1_f_y);

  c1_e_hoistedGlobal = *chartInstance->c1_stateFb;

  c1_g_y = NULL;

  sf_mex_assign(&c1_g_y, sf_mex_create("y", &c1_e_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 5, c1_g_y);

  c1_f_hoistedGlobal = chartInstance->c1_aacCounter;

  c1_h_y = NULL;

  sf_mex_assign(&c1_h_y, sf_mex_create("y", &c1_f_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 6, c1_h_y);

  c1_g_hoistedGlobal = chartInstance->c1_aac_clutchStep;

  c1_i_y = NULL;

  sf_mex_assign(&c1_i_y, sf_mex_create("y", &c1_g_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 7, c1_i_y);

  c1_h_hoistedGlobal = chartInstance->c1_aac_clutchValue;

  c1_j_y = NULL;

  sf_mex_assign(&c1_j_y, sf_mex_create("y", &c1_h_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 8, c1_j_y);

  c1_i_hoistedGlobal = chartInstance->c1_aac_dtRelease;

  c1_k_y = NULL;

  sf_mex_assign(&c1_k_y, sf_mex_create("y", &c1_i_hoistedGlobal, 6, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 9, c1_k_y);

  c1_j_hoistedGlobal = chartInstance->c1_autoXCounter;

  c1_l_y = NULL;

  sf_mex_assign(&c1_l_y, sf_mex_create("y", &c1_j_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 10, c1_l_y);

  c1_k_hoistedGlobal = chartInstance->c1_b_autoXCounter;

  c1_m_y = NULL;

  sf_mex_assign(&c1_m_y, sf_mex_create("y", &c1_k_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 11, c1_m_y);

  c1_l_hoistedGlobal = chartInstance->c1_autoX_clutchStep;

  c1_n_y = NULL;

  sf_mex_assign(&c1_n_y, sf_mex_create("y", &c1_l_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 12, c1_n_y);

  c1_m_hoistedGlobal = chartInstance->c1_b_autoX_clutchStep;

  c1_o_y = NULL;

  sf_mex_assign(&c1_o_y, sf_mex_create("y", &c1_m_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 13, c1_o_y);

  c1_n_hoistedGlobal = chartInstance->c1_autoX_clutchValue;

  c1_p_y = NULL;

  sf_mex_assign(&c1_p_y, sf_mex_create("y", &c1_n_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 14, c1_p_y);

  c1_o_hoistedGlobal = chartInstance->c1_b_autoX_clutchValue;

  c1_q_y = NULL;

  sf_mex_assign(&c1_q_y, sf_mex_create("y", &c1_o_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 15, c1_q_y);

  c1_p_hoistedGlobal = chartInstance->c1_autoX_dtRelease;

  c1_r_y = NULL;

  sf_mex_assign(&c1_r_y, sf_mex_create("y", &c1_p_hoistedGlobal, 6, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 16, c1_r_y);

  c1_q_hoistedGlobal = chartInstance->c1_b_autoX_dtRelease;

  c1_s_y = NULL;

  sf_mex_assign(&c1_s_y, sf_mex_create("y", &c1_q_hoistedGlobal, 6, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 17, c1_s_y);

  c1_r_hoistedGlobal = chartInstance->c1_buzzerCounter;

  c1_t_y = NULL;

  sf_mex_assign(&c1_t_y, sf_mex_create("y", &c1_r_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 18, c1_t_y);

  c1_s_hoistedGlobal = chartInstance->c1_counterWait;

  c1_u_y = NULL;

  sf_mex_assign(&c1_u_y, sf_mex_create("y", &c1_s_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 19, c1_u_y);

  c1_t_hoistedGlobal = chartInstance->c1_b_counterWait;

  c1_v_y = NULL;

  sf_mex_assign(&c1_v_y, sf_mex_create("y", &c1_t_hoistedGlobal, 0, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 20, c1_v_y);

  c1_u_hoistedGlobal = chartInstance->c1_lastAacCom;

  c1_w_y = NULL;

  sf_mex_assign(&c1_w_y, sf_mex_create("y", &c1_u_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 21, c1_w_y);

  c1_v_hoistedGlobal = chartInstance->c1_lastAutoXCom;

  c1_x_y = NULL;

  sf_mex_assign(&c1_x_y, sf_mex_create("y", &c1_v_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 22, c1_x_y);

  c1_w_hoistedGlobal = chartInstance->c1_lastCom;

  c1_y_y = NULL;

  sf_mex_assign(&c1_y_y, sf_mex_create("y", &c1_w_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 23, c1_y_y);

  c1_x_hoistedGlobal = chartInstance->c1_lastShift;

  c1_ab_y = NULL;

  sf_mex_assign(&c1_ab_y, sf_mex_create("y", &c1_x_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 24, c1_ab_y);

  c1_y_hoistedGlobal = chartInstance->c1_lastShiftCom;

  c1_bb_y = NULL;

  sf_mex_assign(&c1_bb_y, sf_mex_create("y", &c1_y_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 25, c1_bb_y);

  c1_cb_y = NULL;

  sf_mex_assign(&c1_cb_y, sf_mex_create("y", chartInstance->c1_lastTryShift, 5,

    0U, 1U, 0U, 2, 1, 2), false);

  sf_mex_setcell(c1_y, 26, c1_cb_y);

  c1_ab_hoistedGlobal = chartInstance->c1_startCounter;

  c1_db_y = NULL;

  sf_mex_assign(&c1_db_y, sf_mex_create("y", &c1_ab_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 27, c1_db_y);

  c1_bb_hoistedGlobal = chartInstance->c1_ticksCounter;

  c1_eb_y = NULL;

  sf_mex_assign(&c1_eb_y, sf_mex_create("y", &c1_bb_hoistedGlobal, 6, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 28, c1_eb_y);

  c1_cb_hoistedGlobal = chartInstance->c1_timerCounter;

  c1_fb_y = NULL;

  sf_mex_assign(&c1_fb_y, sf_mex_create("y", &c1_cb_hoistedGlobal, 5, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 29, c1_fb_y);

  c1_db_hoistedGlobal = chartInstance->c1_is_active_c1_GCU_Model_genCode;

  c1_gb_y = NULL;

  sf_mex_assign(&c1_gb_y, sf_mex_create("y", &c1_db_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 30, c1_gb_y);

  c1_eb_hoistedGlobal = chartInstance->c1_is_active_GEARSHIFT;

  c1_hb_y = NULL;

  sf_mex_assign(&c1_hb_y, sf_mex_create("y", &c1_eb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 31, c1_hb_y);

  c1_fb_hoistedGlobal = chartInstance->c1_is_active_NEUTRAL_STATE;

  c1_ib_y = NULL;

  sf_mex_assign(&c1_ib_y, sf_mex_create("y", &c1_fb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 32, c1_ib_y);

  c1_gb_hoistedGlobal = chartInstance->c1_is_active_MODES;

  c1_jb_y = NULL;

  sf_mex_assign(&c1_jb_y, sf_mex_create("y", &c1_gb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 33, c1_jb_y);

  c1_hb_hoistedGlobal = chartInstance->c1_is_active_START_ENGINE;

  c1_kb_y = NULL;

  sf_mex_assign(&c1_kb_y, sf_mex_create("y", &c1_hb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 34, c1_kb_y);

  c1_ib_hoistedGlobal = chartInstance->c1_is_active_SCAN_ADC;

  c1_lb_y = NULL;

  sf_mex_assign(&c1_lb_y, sf_mex_create("y", &c1_ib_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 35, c1_lb_y);

  c1_jb_hoistedGlobal = chartInstance->c1_is_active_EEPROM_TRIGGER;

  c1_mb_y = NULL;

  sf_mex_assign(&c1_mb_y, sf_mex_create("y", &c1_jb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 36, c1_mb_y);

  c1_kb_hoistedGlobal = chartInstance->c1_is_active_ANTISTALL_ENABLE;

  c1_nb_y = NULL;

  sf_mex_assign(&c1_nb_y, sf_mex_create("y", &c1_kb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 37, c1_nb_y);

  c1_lb_hoistedGlobal = chartInstance->c1_is_GEARSHIFT;

  c1_ob_y = NULL;

  sf_mex_assign(&c1_ob_y, sf_mex_create("y", &c1_lb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 38, c1_ob_y);

  c1_mb_hoistedGlobal = chartInstance->c1_is_UP_START;

  c1_pb_y = NULL;

  sf_mex_assign(&c1_pb_y, sf_mex_create("y", &c1_mb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 39, c1_pb_y);

  c1_nb_hoistedGlobal = chartInstance->c1_is_UP_PUSH;

  c1_qb_y = NULL;

  sf_mex_assign(&c1_qb_y, sf_mex_create("y", &c1_nb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 40, c1_qb_y);

  c1_ob_hoistedGlobal = chartInstance->c1_is_UP_REBOUND;

  c1_rb_y = NULL;

  sf_mex_assign(&c1_rb_y, sf_mex_create("y", &c1_ob_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 41, c1_rb_y);

  c1_pb_hoistedGlobal = chartInstance->c1_is_DOWN_START;

  c1_sb_y = NULL;

  sf_mex_assign(&c1_sb_y, sf_mex_create("y", &c1_pb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 42, c1_sb_y);

  c1_qb_hoistedGlobal = chartInstance->c1_is_DOWN_BRAKE;

  c1_tb_y = NULL;

  sf_mex_assign(&c1_tb_y, sf_mex_create("y", &c1_qb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 43, c1_tb_y);

  c1_rb_hoistedGlobal = chartInstance->c1_is_NEUTRAL_STATE;

  c1_ub_y = NULL;

  sf_mex_assign(&c1_ub_y, sf_mex_create("y", &c1_rb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 44, c1_ub_y);

  c1_sb_hoistedGlobal = chartInstance->c1_is_MODES;

  c1_vb_y = NULL;

  sf_mex_assign(&c1_vb_y, sf_mex_create("y", &c1_sb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 45, c1_vb_y);

  c1_tb_hoistedGlobal = chartInstance->c1_is_ACC;

  c1_wb_y = NULL;

  sf_mex_assign(&c1_wb_y, sf_mex_create("y", &c1_tb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 46, c1_wb_y);

  c1_ub_hoistedGlobal = chartInstance->c1_is_START_ENGINE;

  c1_xb_y = NULL;

  sf_mex_assign(&c1_xb_y, sf_mex_create("y", &c1_ub_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 47, c1_xb_y);

  c1_vb_hoistedGlobal = chartInstance->c1_is_ACTIVE;

  c1_yb_y = NULL;

  sf_mex_assign(&c1_yb_y, sf_mex_create("y", &c1_vb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 48, c1_yb_y);

  c1_wb_hoistedGlobal = chartInstance->c1_is_UPSHIFTING;

  c1_ac_y = NULL;

  sf_mex_assign(&c1_ac_y, sf_mex_create("y", &c1_wb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 49, c1_ac_y);

  c1_xb_hoistedGlobal = chartInstance->c1_is_DOWNSHIFTING;

  c1_bc_y = NULL;

  sf_mex_assign(&c1_bc_y, sf_mex_create("y", &c1_xb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 50, c1_bc_y);

  c1_yb_hoistedGlobal = chartInstance->c1_is_MANUAL_MODES;

  c1_cc_y = NULL;

  sf_mex_assign(&c1_cc_y, sf_mex_create("y", &c1_yb_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 51, c1_cc_y);

  c1_ac_hoistedGlobal = chartInstance->c1_is_ACCELERATION;

  c1_dc_y = NULL;

  sf_mex_assign(&c1_dc_y, sf_mex_create("y", &c1_ac_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 52, c1_dc_y);

  c1_bc_hoistedGlobal = chartInstance->c1_is_SCAN_ADC;

  c1_ec_y = NULL;

  sf_mex_assign(&c1_ec_y, sf_mex_create("y", &c1_bc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 53, c1_ec_y);

  c1_cc_hoistedGlobal = chartInstance->c1_is_EEPROM_TRIGGER;

  c1_fc_y = NULL;

  sf_mex_assign(&c1_fc_y, sf_mex_create("y", &c1_cc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 54, c1_fc_y);

  c1_dc_hoistedGlobal = chartInstance->c1_is_AUTOCROSS;

  c1_gc_y = NULL;

  sf_mex_assign(&c1_gc_y, sf_mex_create("y", &c1_dc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 55, c1_gc_y);

  c1_ec_hoistedGlobal = chartInstance->c1_is_LAUNCH;

  c1_hc_y = NULL;

  sf_mex_assign(&c1_hc_y, sf_mex_create("y", &c1_ec_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 56, c1_hc_y);

  c1_fc_hoistedGlobal = chartInstance->c1_b_is_ACTIVE;

  c1_ic_y = NULL;

  sf_mex_assign(&c1_ic_y, sf_mex_create("y", &c1_fc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 57, c1_ic_y);

  c1_gc_hoistedGlobal = chartInstance->c1_is_ANTISTALL_ENABLE;

  c1_jc_y = NULL;

  sf_mex_assign(&c1_jc_y, sf_mex_create("y", &c1_gc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 58, c1_jc_y);

  c1_hc_hoistedGlobal = chartInstance->c1_is_ACCELERATION_PID;

  c1_kc_y = NULL;

  sf_mex_assign(&c1_kc_y, sf_mex_create("y", &c1_hc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 59, c1_kc_y);

  c1_ic_hoistedGlobal = chartInstance->c1_is_LAUNCH0;

  c1_lc_y = NULL;

  sf_mex_assign(&c1_lc_y, sf_mex_create("y", &c1_ic_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 60, c1_lc_y);

  c1_jc_hoistedGlobal = chartInstance->c1_c_is_ACTIVE;

  c1_mc_y = NULL;

  sf_mex_assign(&c1_mc_y, sf_mex_create("y", &c1_jc_hoistedGlobal, 3, 0U, 0U, 0U,

    0), false);

  sf_mex_setcell(c1_y, 61, c1_mc_y);

  sf_mex_assign(&c1_st, c1_y, false);

  return c1_st;

}



static void set_sim_state_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance, const mxArray *c1_st)

{

  c1_r_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_st));

  chartInstance->c1_doSetSimStateSideEffects = 1U;

  c1_update_debugger_state_c1_GCU_Model_genCode(chartInstance);

  sf_mex_destroy(&c1_st);

}



static void c1_set_sim_state_side_effects_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  if (chartInstance->c1_doSetSimStateSideEffects != 0) {

    if (chartInstance->c1_is_active_MODES == 1U) {

      chartInstance->c1_tp_MODES = 1U;

    } else {

      chartInstance->c1_tp_MODES = 0U;

    }



    if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

      chartInstance->c1_tp_ACCELERATION = 1U;

    } else {

      chartInstance->c1_tp_ACCELERATION = 0U;

    }



    if (chartInstance->c1_is_ACCELERATION == c1_IN_ACC) {

      chartInstance->c1_tp_ACC = 1U;

    } else {

      chartInstance->c1_tp_ACC = 0U;

    }



    if (chartInstance->c1_is_ACC == c1_IN_ACTIVE) {

      chartInstance->c1_tp_ACTIVE = 1U;

    } else {

      chartInstance->c1_tp_ACTIVE = 0U;

    }



    if (chartInstance->c1_is_ACTIVE == c1_IN_READY) {

      chartInstance->c1_tp_READY = 1U;

    } else {

      chartInstance->c1_tp_READY = 0U;

    }



    if (chartInstance->c1_is_ACTIVE == c1_IN_RELEASING) {

      chartInstance->c1_tp_RELEASING = 1U;

    } else {

      chartInstance->c1_tp_RELEASING = 0U;

    }



    if (chartInstance->c1_is_ACTIVE == c1_IN_RUNNING) {

      chartInstance->c1_tp_RUNNING = 1U;

    } else {

      chartInstance->c1_tp_RUNNING = 0U;

    }



    if (chartInstance->c1_is_ACTIVE == c1_IN_START) {

      chartInstance->c1_tp_START = 1U;

    } else {

      chartInstance->c1_tp_START = 0U;

    }



    if (chartInstance->c1_is_ACTIVE == c1_IN_START_RELEASE) {

      chartInstance->c1_tp_START_RELEASE = 1U;

    } else {

      chartInstance->c1_tp_START_RELEASE = 0U;

    }



    if (chartInstance->c1_is_ACC == c1_IN_STOPPING) {

      chartInstance->c1_tp_STOPPING = 1U;

    } else {

      chartInstance->c1_tp_STOPPING = 0U;

    }



    if (chartInstance->c1_is_ACCELERATION == c1_IN_DEFAULT) {

      chartInstance->c1_tp_DEFAULT = 1U;

    } else {

      chartInstance->c1_tp_DEFAULT = 0U;

    }



    if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

      chartInstance->c1_tp_ACCELERATION_PID = 1U;

    } else {

      chartInstance->c1_tp_ACCELERATION_PID = 0U;

    }



    if (chartInstance->c1_is_ACCELERATION_PID == c1_b_IN_DEFAULT) {

      chartInstance->c1_c_tp_DEFAULT = 1U;

    } else {

      chartInstance->c1_c_tp_DEFAULT = 0U;

    }



    if (chartInstance->c1_is_ACCELERATION_PID == c1_IN_LAUNCH0) {

      chartInstance->c1_tp_LAUNCH0 = 1U;

    } else {

      chartInstance->c1_tp_LAUNCH0 = 0U;

    }



    if (chartInstance->c1_is_LAUNCH0 == c1_IN_ACTIVE) {

      chartInstance->c1_c_tp_ACTIVE = 1U;

      if (sf_mex_sub(chartInstance->c1_setSimStateSideEffectsInfo,

                     "setSimStateSideEffectsInfo", 1, 16) == 0.0) {

        sf_call_output_fcn_enable(chartInstance->S, 16, "ramp", 0);

      }

    } else {

      chartInstance->c1_c_tp_ACTIVE = 0U;

      if (sf_mex_sub(chartInstance->c1_setSimStateSideEffectsInfo,

                     "setSimStateSideEffectsInfo", 1, 16) > 0.0) {

        sf_call_output_fcn_disable(chartInstance->S, 16, "ramp", 0);

      }

    }



    if (chartInstance->c1_c_is_ACTIVE == c1_IN_READY) {

      chartInstance->c1_c_tp_READY = 1U;

    } else {

      chartInstance->c1_c_tp_READY = 0U;

    }



    if (chartInstance->c1_c_is_ACTIVE == c1_IN_RELEASE) {

      chartInstance->c1_tp_RELEASE = 1U;

    } else {

      chartInstance->c1_tp_RELEASE = 0U;

    }



    if (chartInstance->c1_c_is_ACTIVE == c1_IN_RPM_LIMITER) {

      chartInstance->c1_tp_RPM_LIMITER = 1U;

    } else {

      chartInstance->c1_tp_RPM_LIMITER = 0U;

    }



    if (chartInstance->c1_c_is_ACTIVE == c1_b_IN_RUNNING) {

      chartInstance->c1_c_tp_RUNNING = 1U;

    } else {

      chartInstance->c1_c_tp_RUNNING = 0U;

    }



    if (chartInstance->c1_c_is_ACTIVE == c1_b_IN_START) {

      chartInstance->c1_c_tp_START = 1U;

    } else {

      chartInstance->c1_c_tp_START = 0U;

    }



    if (chartInstance->c1_is_LAUNCH0 == c1_IN_STOPPING) {

      chartInstance->c1_c_tp_STOPPING = 1U;

    } else {

      chartInstance->c1_c_tp_STOPPING = 0U;

    }



    if (chartInstance->c1_is_MODES == c1_IN_AUTOCROSS) {

      chartInstance->c1_tp_AUTOCROSS = 1U;

    } else {

      chartInstance->c1_tp_AUTOCROSS = 0U;

    }



    if (chartInstance->c1_is_AUTOCROSS == c1_b_IN_DEFAULT) {

      chartInstance->c1_b_tp_DEFAULT = 1U;

    } else {

      chartInstance->c1_b_tp_DEFAULT = 0U;

    }



    if (chartInstance->c1_is_AUTOCROSS == c1_IN_LAUNCH) {

      chartInstance->c1_tp_LAUNCH = 1U;

    } else {

      chartInstance->c1_tp_LAUNCH = 0U;

    }



    if (chartInstance->c1_is_LAUNCH == c1_IN_ACTIVE) {

      chartInstance->c1_b_tp_ACTIVE = 1U;

    } else {

      chartInstance->c1_b_tp_ACTIVE = 0U;

    }



    if (chartInstance->c1_b_is_ACTIVE == c1_IN_READY) {

      chartInstance->c1_b_tp_READY = 1U;

    } else {

      chartInstance->c1_b_tp_READY = 0U;

    }



    if (chartInstance->c1_b_is_ACTIVE == c1_IN_RELEASING) {

      chartInstance->c1_b_tp_RELEASING = 1U;

    } else {

      chartInstance->c1_b_tp_RELEASING = 0U;

    }



    if (chartInstance->c1_b_is_ACTIVE == c1_IN_RUNNING) {

      chartInstance->c1_b_tp_RUNNING = 1U;

    } else {

      chartInstance->c1_b_tp_RUNNING = 0U;

    }



    if (chartInstance->c1_b_is_ACTIVE == c1_IN_START) {

      chartInstance->c1_b_tp_START = 1U;

    } else {

      chartInstance->c1_b_tp_START = 0U;

    }



    if (chartInstance->c1_b_is_ACTIVE == c1_IN_START_RELEASE) {

      chartInstance->c1_b_tp_START_RELEASE = 1U;

    } else {

      chartInstance->c1_b_tp_START_RELEASE = 0U;

    }



    if (chartInstance->c1_is_LAUNCH == c1_IN_STOPPING) {

      chartInstance->c1_b_tp_STOPPING = 1U;

    } else {

      chartInstance->c1_b_tp_STOPPING = 0U;

    }



    if (chartInstance->c1_is_MODES == c1_IN_INIT) {

      chartInstance->c1_tp_INIT = 1U;

    } else {

      chartInstance->c1_tp_INIT = 0U;

    }



    if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

      chartInstance->c1_tp_MANUAL_MODES = 1U;

    } else {

      chartInstance->c1_tp_MANUAL_MODES = 0U;

    }



    if (chartInstance->c1_is_MANUAL_MODES == c1_IN_ENDURANCE) {

      chartInstance->c1_tp_ENDURANCE = 1U;

    } else {

      chartInstance->c1_tp_ENDURANCE = 0U;

    }



    if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

      chartInstance->c1_tp_SKIDPAD = 1U;

    } else {

      chartInstance->c1_tp_SKIDPAD = 0U;

    }



    if (chartInstance->c1_is_active_NEUTRAL_STATE == 1U) {

      chartInstance->c1_tp_NEUTRAL_STATE = 1U;

    } else {

      chartInstance->c1_tp_NEUTRAL_STATE = 0U;

    }



    if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_NEUTRAL) {

      chartInstance->c1_tp_NEUTRAL = 1U;

    } else {

      chartInstance->c1_tp_NEUTRAL = 0U;

    }



    if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_NO_NEUTRAL) {

      chartInstance->c1_tp_NO_NEUTRAL = 1U;

    } else {

      chartInstance->c1_tp_NO_NEUTRAL = 0U;

    }



    if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) {

      chartInstance->c1_tp_SET_NEUTRAL = 1U;

    } else {

      chartInstance->c1_tp_SET_NEUTRAL = 0U;

    }



    if (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_UNSET_NEUTRAL) {

      chartInstance->c1_tp_UNSET_NEUTRAL = 1U;

    } else {

      chartInstance->c1_tp_UNSET_NEUTRAL = 0U;

    }



    if (chartInstance->c1_is_active_GEARSHIFT == 1U) {

      chartInstance->c1_tp_GEARSHIFT = 1U;

      if (sf_mex_sub(chartInstance->c1_setSimStateSideEffectsInfo,

                     "setSimStateSideEffectsInfo", 1, 42) == 0.0) {

        sf_call_output_fcn_enable(chartInstance->S, 26, "checkCurrent", 0);

      }

    } else {

      chartInstance->c1_tp_GEARSHIFT = 0U;

      if (sf_mex_sub(chartInstance->c1_setSimStateSideEffectsInfo,

                     "setSimStateSideEffectsInfo", 1, 42) > 0.0) {

        sf_call_output_fcn_disable(chartInstance->S, 26, "checkCurrent", 0);

      }

    }



    if (chartInstance->c1_is_GEARSHIFT == c1_IN_DOWNSHIFTING) {

      chartInstance->c1_tp_DOWNSHIFTING = 1U;

    } else {

      chartInstance->c1_tp_DOWNSHIFTING = 0U;

    }



    if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_BRAKE) {

      chartInstance->c1_tp_DOWN_BRAKE = 1U;

    } else {

      chartInstance->c1_tp_DOWN_BRAKE = 0U;

    }



    if (chartInstance->c1_is_DOWN_BRAKE == c1_IN_ChangeClutch) {

      chartInstance->c1_b_tp_ChangeClutch = 1U;

    } else {

      chartInstance->c1_b_tp_ChangeClutch = 0U;

    }



    if (chartInstance->c1_is_DOWN_BRAKE == c1_b_IN_Default) {

      chartInstance->c1_e_tp_Default = 1U;

    } else {

      chartInstance->c1_e_tp_Default = 0U;

    }



    if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_PUSH) {

      chartInstance->c1_tp_DOWN_PUSH = 1U;

    } else {

      chartInstance->c1_tp_DOWN_PUSH = 0U;

    }



    if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_REBOUND) {

      chartInstance->c1_tp_DOWN_REBOUND = 1U;

    } else {

      chartInstance->c1_tp_DOWN_REBOUND = 0U;

    }



    if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_START) {

      chartInstance->c1_tp_DOWN_START = 1U;

    } else {

      chartInstance->c1_tp_DOWN_START = 0U;

    }



    if (chartInstance->c1_is_DOWN_START == c1_IN_ChangeClutch) {

      chartInstance->c1_tp_ChangeClutch = 1U;

    } else {

      chartInstance->c1_tp_ChangeClutch = 0U;

    }



    if (chartInstance->c1_is_DOWN_START == c1_b_IN_Default) {

      chartInstance->c1_d_tp_Default = 1U;

    } else {

      chartInstance->c1_d_tp_Default = 0U;

    }



    if (chartInstance->c1_is_DOWN_START == c1_b_IN_SettingNeutral) {

      chartInstance->c1_c_tp_SettingNeutral = 1U;

    } else {

      chartInstance->c1_c_tp_SettingNeutral = 0U;

    }



    if (chartInstance->c1_is_GEARSHIFT == c1_IN_DOWN_END) {

      chartInstance->c1_tp_DOWN_END = 1U;

    } else {

      chartInstance->c1_tp_DOWN_END = 0U;

    }



    if (chartInstance->c1_is_GEARSHIFT == c1_IN_IDLE) {

      chartInstance->c1_tp_IDLE = 1U;

    } else {

      chartInstance->c1_tp_IDLE = 0U;

    }



    if (chartInstance->c1_is_GEARSHIFT == c1_IN_INIT) {

      chartInstance->c1_b_tp_INIT = 1U;

    } else {

      chartInstance->c1_b_tp_INIT = 0U;

    }



    if (chartInstance->c1_is_GEARSHIFT == c1_IN_UPSHIFTING) {

      chartInstance->c1_tp_UPSHIFTING = 1U;

    } else {

      chartInstance->c1_tp_UPSHIFTING = 0U;

    }



    if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_BRAKE) {

      chartInstance->c1_tp_UP_BRAKE = 1U;

    } else {

      chartInstance->c1_tp_UP_BRAKE = 0U;

    }



    if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_PUSH) {

      chartInstance->c1_tp_UP_PUSH = 1U;

    } else {

      chartInstance->c1_tp_UP_PUSH = 0U;

    }



    if (chartInstance->c1_is_UP_PUSH == c1_IN_CutOff) {

      chartInstance->c1_tp_CutOff = 1U;

    } else {

      chartInstance->c1_tp_CutOff = 0U;

    }



    if (chartInstance->c1_is_UP_PUSH == c1_b_IN_Default) {

      chartInstance->c1_b_tp_Default = 1U;

    } else {

      chartInstance->c1_b_tp_Default = 0U;

    }



    if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_REBOUND) {

      chartInstance->c1_tp_UP_REBOUND = 1U;

    } else {

      chartInstance->c1_tp_UP_REBOUND = 0U;

    }



    if (chartInstance->c1_is_UP_REBOUND == c1_IN_Default) {

      chartInstance->c1_tp_Default = 1U;

    } else {

      chartInstance->c1_tp_Default = 0U;

    }



    if (chartInstance->c1_is_UP_REBOUND == c1_IN_SettingNeutral) {

      chartInstance->c1_tp_SettingNeutral = 1U;

    } else {

      chartInstance->c1_tp_SettingNeutral = 0U;

    }



    if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_START) {

      chartInstance->c1_tp_UP_START = 1U;

    } else {

      chartInstance->c1_tp_UP_START = 0U;

    }



    if (chartInstance->c1_is_UP_START == c1_IN_Default) {

      chartInstance->c1_c_tp_Default = 1U;

    } else {

      chartInstance->c1_c_tp_Default = 0U;

    }



    if (chartInstance->c1_is_UP_START == c1_IN_SettingNeutral) {

      chartInstance->c1_b_tp_SettingNeutral = 1U;

    } else {

      chartInstance->c1_b_tp_SettingNeutral = 0U;

    }



    if (chartInstance->c1_is_GEARSHIFT == c1_IN_UP_END) {

      chartInstance->c1_tp_UP_END = 1U;

    } else {

      chartInstance->c1_tp_UP_END = 0U;

    }



    if (chartInstance->c1_is_active_START_ENGINE == 1U) {

      chartInstance->c1_tp_START_ENGINE = 1U;

    } else {

      chartInstance->c1_tp_START_ENGINE = 0U;

    }



    if (chartInstance->c1_is_START_ENGINE == c1_c_IN_START) {

      chartInstance->c1_d_tp_START = 1U;

    } else {

      chartInstance->c1_d_tp_START = 0U;

    }



    if (chartInstance->c1_is_START_ENGINE == c1_IN_STOP) {

      chartInstance->c1_tp_STOP = 1U;

    } else {

      chartInstance->c1_tp_STOP = 0U;

    }



    if (chartInstance->c1_is_START_ENGINE == c1_b_IN_WAIT) {

      chartInstance->c1_b_tp_WAIT = 1U;

    } else {

      chartInstance->c1_b_tp_WAIT = 0U;

    }



    if (chartInstance->c1_is_active_SCAN_ADC == 1U) {

      chartInstance->c1_tp_SCAN_ADC = 1U;

      if (sf_mex_sub(chartInstance->c1_setSimStateSideEffectsInfo,

                     "setSimStateSideEffectsInfo", 1, 72) == 0.0) {

        sf_call_output_fcn_enable(chartInstance->S, 27, "ScanADC", 0);

      }

    } else {

      chartInstance->c1_tp_SCAN_ADC = 0U;

      if (sf_mex_sub(chartInstance->c1_setSimStateSideEffectsInfo,

                     "setSimStateSideEffectsInfo", 1, 72) > 0.0) {

        sf_call_output_fcn_disable(chartInstance->S, 27, "ScanADC", 0);

      }

    }



    if (chartInstance->c1_is_SCAN_ADC == c1_IN_SCAN) {

      chartInstance->c1_tp_SCAN = 1U;

    } else {

      chartInstance->c1_tp_SCAN = 0U;

    }



    if (chartInstance->c1_is_active_EEPROM_TRIGGER == 1U) {

      chartInstance->c1_tp_EEPROM_TRIGGER = 1U;

    } else {

      chartInstance->c1_tp_EEPROM_TRIGGER = 0U;

    }



    if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_SEND) {

      chartInstance->c1_tp_SEND = 1U;

    } else {

      chartInstance->c1_tp_SEND = 0U;

    }



    if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_WAIT) {

      chartInstance->c1_tp_WAIT = 1U;

    } else {

      chartInstance->c1_tp_WAIT = 0U;

    }



    if (chartInstance->c1_is_active_ANTISTALL_ENABLE == 1U) {

      chartInstance->c1_tp_ANTISTALL_ENABLE = 1U;

    } else {

      chartInstance->c1_tp_ANTISTALL_ENABLE = 0U;

    }



    if (chartInstance->c1_is_ANTISTALL_ENABLE == c1_IN_DISABLE) {

      chartInstance->c1_tp_DISABLE = 1U;

    } else {

      chartInstance->c1_tp_DISABLE = 0U;

    }



    if (chartInstance->c1_is_ANTISTALL_ENABLE == c1_IN_ENABLE) {

      chartInstance->c1_tp_ENABLE = 1U;

    } else {

      chartInstance->c1_tp_ENABLE = 0U;

    }



    chartInstance->c1_doSetSimStateSideEffects = 0U;

  }

}



static void finalize_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  c1_sdiTerminate(chartInstance);

  sf_mex_destroy(&chartInstance->c1_setSimStateSideEffectsInfo);

}



static void sf_gateway_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  int32_T c1_i4;

  int32_T c1_i5;

  int32_T c1_i6;

  int32_T c1_i7;

  int32_T c1_i8;

  int32_T c1_i9;

  int32_T c1_i10;

  int32_T c1_i11;

  int32_T c1_i12;

  c1_set_sim_state_side_effects_c1_GCU_Model_genCode(chartInstance);

  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

  _sfTime_ = sf_get_time(chartInstance->S);

  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c1_sfEvent);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_canErrorCom, 46U);

  _SFD_DATA_RANGE_CHECK(*chartInstance->c1_I2_L, 45U);

  _SFD_DATA_RANGE_CHECK(*chartInstance->c1_I1_L, 44U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_pidSubMode, 43U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_currSlipTarget, 42U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_currSlip, 41U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_currVhSpeed, 40U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_currRpm, 39U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_currTps, 38U);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_currGear, 37U);

  for (c1_i4 = 0; c1_i4 < 2; c1_i4++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_gearMotorCurent_1_2)[c1_i4],

                          36U);

  }



  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_antiStallFb, 35U);

  for (c1_i5 = 0; c1_i5 < 8; c1_i5++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_antiStall_parameters)

                          [c1_i5], 34U);

  }



  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_slipUpdateCounter, 33U);

  for (c1_i6 = 0; c1_i6 < 16; c1_i6++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_autoX_parameters)[c1_i6],

                          32U);

  }



  for (c1_i7 = 0; c1_i7 < 2; c1_i7++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_autoXCom)[c1_i7], 31U);

  }



  for (c1_i8 = 0; c1_i8 < 24; c1_i8++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_timings)[c1_i8], 30U);

  }



  for (c1_i9 = 0; c1_i9 < 16; c1_i9++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_acc_parameters)[c1_i9],

                          29U);

  }



  for (c1_i10 = 0; c1_i10 < 2; c1_i10++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_modeCom)[c1_i10], 28U);

  }



  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_clutchTarget, 27U);

  for (c1_i11 = 0; c1_i11 < 2; c1_i11++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_aacCom)[c1_i11], 26U);

  }



  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_startEngCom, 25U);

  for (c1_i12 = 0; c1_i12 < 2; c1_i12++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_shiftCom)[c1_i12], 24U);

  }



  chartInstance->c1_sfEvent = CALL_EVENT;

  c1_c1_GCU_Model_genCode(chartInstance);

  _SFD_SYMBOL_SCOPE_POP();

}



static void mdl_start_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct *

  chartInstance)

{

  c1_init_sf_message_store_memory(chartInstance);

  c1_sdiInitialize(chartInstance);

  sim_mode_is_external(chartInstance->S);

}



static void c1_enter_internal_c1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  chartInstance->c1_is_active_MODES = 1U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 1, 418U, (int32_T)

    (chartInstance->c1_is_active_MODES == 1));

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 35U, chartInstance->c1_sfEvent);

  chartInstance->c1_tp_MODES = 1U;

  chartInstance->c1_lastAacCom = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

    &chartInstance->c1_lastAacCom);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

  chartInstance->c1_lastShiftCom = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 32, 681U, (void *)

    &chartInstance->c1_lastShiftCom);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShiftCom, 3U);

  chartInstance->c1_lastAutoXCom = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

    &chartInstance->c1_lastAutoXCom);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

  chartInstance->c1_buzzerCounter = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 34, 1063U, (void *)

    &chartInstance->c1_buzzerCounter);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_buzzerCounter, 0U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 78U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_MODES == c1_IN_INIT) {

  } else {

    chartInstance->c1_is_MODES = c1_IN_INIT;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

      &chartInstance->c1_is_MODES);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

      (chartInstance->c1_is_MODES == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

      (chartInstance->c1_is_MODES == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

      (chartInstance->c1_is_MODES == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

      (chartInstance->c1_is_MODES == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

      (chartInstance->c1_is_MODES == 5));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_INIT = 1U;

    sf_call_output_fcn_call(chartInstance->S, 14, "BuzzerOn", 0);

  }



  chartInstance->c1_is_active_NEUTRAL_STATE = 1U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 36, 31U, (int32_T)

    (chartInstance->c1_is_active_NEUTRAL_STATE == 1));

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 79U, chartInstance->c1_sfEvent);

  chartInstance->c1_tp_NEUTRAL_STATE = 1U;

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 13U, chartInstance->c1_sfEvent);

  chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NEUTRAL;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

    &chartInstance->c1_is_NEUTRAL_STATE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 4));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 1);

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

  chartInstance->c1_tp_NEUTRAL = 1U;

  if (chartInstance->c1_is_active_GEARSHIFT == 1U) {

  } else {

    chartInstance->c1_is_active_GEARSHIFT = 1U;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 41, 1U, (int32_T)

      (chartInstance->c1_is_active_GEARSHIFT == 1));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 7U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_GEARSHIFT = 1U;

    chartInstance->c1_ticksCounter = 0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

      &chartInstance->c1_ticksCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    sf_call_output_fcn_enable(chartInstance->S, 26, "checkCurrent", 0);

  }



  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 0U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_GEARSHIFT == c1_IN_INIT) {

  } else {

    chartInstance->c1_is_GEARSHIFT = c1_IN_INIT;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

      &chartInstance->c1_is_GEARSHIFT);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 21U, chartInstance->c1_sfEvent);

    chartInstance->c1_b_tp_INIT = 1U;

    chartInstance->c1_ticksCounter = 0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

      &chartInstance->c1_ticksCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

  }



  chartInstance->c1_is_active_START_ENGINE = 1U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 67, 479U, (int32_T)

    (chartInstance->c1_is_active_START_ENGINE == 1));

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 87U, chartInstance->c1_sfEvent);

  chartInstance->c1_tp_START_ENGINE = 1U;

  chartInstance->c1_lastCom = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 85, 484U, (void *)

    &chartInstance->c1_lastCom);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastCom, 18U);

  chartInstance->c1_startCounter = 0U;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 86, 488U, (void *)

    &chartInstance->c1_startCounter);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_startCounter, 19U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 95U, chartInstance->c1_sfEvent);

  chartInstance->c1_is_START_ENGINE = c1_b_IN_WAIT;

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

    &chartInstance->c1_is_START_ENGINE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 3));

  c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 67, 479U, 1);

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 90U, chartInstance->c1_sfEvent);

  chartInstance->c1_b_tp_WAIT = 1U;

  if (chartInstance->c1_is_active_SCAN_ADC == 1U) {

  } else {

    chartInstance->c1_is_active_SCAN_ADC = 1U;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 71, 929U, (int32_T)

      (chartInstance->c1_is_active_SCAN_ADC == 1));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 84U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_SCAN_ADC = 1U;

    chartInstance->c1_timerCounter = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 87, 938U, (void *)

      &chartInstance->c1_timerCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_timerCounter, 20U);

    sf_call_output_fcn_enable(chartInstance->S, 27, "ScanADC", 0);

  }



  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 147U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_SCAN_ADC == c1_IN_SCAN) {

  } else {

    chartInstance->c1_is_SCAN_ADC = c1_IN_SCAN;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 71, 929U, (void *)

      &chartInstance->c1_is_SCAN_ADC);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 72, 932U, (int32_T)

      (chartInstance->c1_is_SCAN_ADC == 1));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 71, 929U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 85U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_SCAN = 1U;

    _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 86U, chartInstance->c1_sfEvent);

    _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 86U, chartInstance->c1_sfEvent);

    sf_call_output_fcn_call(chartInstance->S, 27, "ScanADC", 0);

    _SFD_SYMBOL_SCOPE_POP();

    _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 86U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 86U, chartInstance->c1_sfEvent);

  }



  chartInstance->c1_is_active_EEPROM_TRIGGER = 1U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 73, 940U, (int32_T)

    (chartInstance->c1_is_active_EEPROM_TRIGGER == 1));

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 4U, chartInstance->c1_sfEvent);

  chartInstance->c1_tp_EEPROM_TRIGGER = 1U;

  chartInstance->c1_counterWait = 0.0;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 84, 950U, (void *)

    &chartInstance->c1_counterWait);

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_counterWait, 17U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 148U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_WAIT) {

  } else {

    chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_WAIT;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 73, 940U, (void *)

      &chartInstance->c1_is_EEPROM_TRIGGER);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

      (chartInstance->c1_is_EEPROM_TRIGGER == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

      (chartInstance->c1_is_EEPROM_TRIGGER == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 73, 940U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 6U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_WAIT = 1U;

    chartInstance->c1_counterWait = 1.0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 84, 950U, (void *)

      &chartInstance->c1_counterWait);

    _SFD_DATA_RANGE_CHECK(chartInstance->c1_counterWait, 17U);

  }



  chartInstance->c1_is_active_ANTISTALL_ENABLE = 1U;

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 76, 1069U, (int32_T)

    (chartInstance->c1_is_active_ANTISTALL_ENABLE == 1));

  _SFD_CS_CALL(STATE_ACTIVE_TAG, 0U, chartInstance->c1_sfEvent);

  chartInstance->c1_tp_ANTISTALL_ENABLE = 1U;

  chartInstance->c1_b_counterWait = 0.0;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 88, 1068U, (void *)

    &chartInstance->c1_b_counterWait);

  _SFD_DATA_RANGE_CHECK(chartInstance->c1_b_counterWait, 21U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 182U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_ANTISTALL_ENABLE == c1_IN_DISABLE) {

  } else {

    chartInstance->c1_is_ANTISTALL_ENABLE = c1_IN_DISABLE;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 76, 1069U, (void *)

      &chartInstance->c1_is_ANTISTALL_ENABLE);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 77, 1070U, (int32_T)

      (chartInstance->c1_is_ANTISTALL_ENABLE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 78, 1072U, (int32_T)

      (chartInstance->c1_is_ANTISTALL_ENABLE == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 76, 1069U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 1U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_DISABLE = 1U;

    *chartInstance->c1_antiStallEnable = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 14, 1073U, (void *)

      chartInstance->c1_antiStallEnable);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_antiStallEnable, 50U);

  }

}



static void c1_c1_GCU_Model_genCode(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i13;

  boolean_T c1_c_out;

  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_active_c1_GCU_Model_genCode == 0U) {

    _SFD_CC_CALL(CHART_ENTER_ENTRY_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_active_c1_GCU_Model_genCode = 1U;

    _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);

    c1_enter_internal_c1_GCU_Model_genCode(chartInstance);

  } else {

    if (chartInstance->c1_is_active_MODES == 0U) {

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 35U,

                   chartInstance->c1_sfEvent);

      switch (chartInstance->c1_is_MODES) {

       case c1_IN_ACCELERATION:

        CV_STATE_EVAL(35, 0, c1_IN_ACCELERATION);

        c1_ACCELERATION(chartInstance);

        break;



       case c1_IN_ACCELERATION_PID:

        CV_STATE_EVAL(35, 0, c1_IN_ACCELERATION_PID);

        c1_ACCELERATION_PID(chartInstance);

        break;



       case c1_IN_AUTOCROSS:

        CV_STATE_EVAL(35, 0, c1_IN_AUTOCROSS);

        c1_AUTOCROSS(chartInstance);

        break;



       case c1_IN_INIT:

        CV_STATE_EVAL(35, 0, c1_IN_INIT);

        c1_INIT(chartInstance);

        break;



       case c1_IN_MANUAL_MODES:

        CV_STATE_EVAL(35, 0, c1_IN_MANUAL_MODES);

        c1_MANUAL_MODES(chartInstance);

        break;



       default:

        CV_STATE_EVAL(35, 0, 0);



        /* Unreachable state, for coverage only */

        chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

        break;

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 35U, chartInstance->c1_sfEvent);

    }



    if (chartInstance->c1_is_active_NEUTRAL_STATE == 0U) {

    } else {

      c1_NEUTRAL_STATE(chartInstance);

    }



    if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

    } else {

      c1_GEARSHIFT(chartInstance);

    }



    if (chartInstance->c1_is_active_START_ENGINE == 0U) {

    } else {

      c1_START_ENGINE(chartInstance);

    }



    if (chartInstance->c1_is_active_SCAN_ADC == 0U) {

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 84U,

                   chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_SCAN_ADC != c1_IN_SCAN) {

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 85U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 86U, chartInstance->c1_sfEvent);

        _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 86U,

                     chartInstance->c1_sfEvent);

        sf_call_output_fcn_call(chartInstance->S, 27, "ScanADC", 0);

        _SFD_SYMBOL_SCOPE_POP();

        _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 86U, chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 86U, chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 85U, chartInstance->c1_sfEvent);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 84U, chartInstance->c1_sfEvent);

    }



    if (chartInstance->c1_is_active_EEPROM_TRIGGER == 0U) {

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 4U,

                   chartInstance->c1_sfEvent);

      switch (chartInstance->c1_is_EEPROM_TRIGGER) {

       case c1_IN_SEND:

        CV_STATE_EVAL(4, 0, c1_IN_SEND);

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 150U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_SEND = 0U;

        chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

          (chartInstance->c1_is_EEPROM_TRIGGER == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

          (chartInstance->c1_is_EEPROM_TRIGGER == 2));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 5U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_WAIT) {

        } else {

          chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_WAIT;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 73, 940U, (void *)

            &chartInstance->c1_is_EEPROM_TRIGGER);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

            (chartInstance->c1_is_EEPROM_TRIGGER == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

            (chartInstance->c1_is_EEPROM_TRIGGER == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 73, 940U, 1);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 6U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_WAIT = 1U;

          chartInstance->c1_counterWait = 1.0;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 84, 950U, (void *)

            &chartInstance->c1_counterWait);

          _SFD_DATA_RANGE_CHECK(chartInstance->c1_counterWait, 17U);

        }



        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 5U, chartInstance->c1_sfEvent);

        break;



       case c1_IN_WAIT:

        CV_STATE_EVAL(4, 0, c1_IN_WAIT);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 149U,

                     chartInstance->c1_sfEvent);

        c1_b_out = (CV_TRANSITION_EVAL(149U, (int32_T)_SFD_CCP_CALL(5U, 149U, 0,

          (boolean_T)CV_RELATIONAL_EVAL(5U, 149U, 0,

          chartInstance->c1_counterWait, 10.0, -1, 5U,

          chartInstance->c1_counterWait >= 10.0) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_b_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 149U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_WAIT = 0U;

          chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

            (chartInstance->c1_is_EEPROM_TRIGGER == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

            (chartInstance->c1_is_EEPROM_TRIGGER == 2));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 6U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_EEPROM_TRIGGER == c1_IN_SEND) {

          } else {

            chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_SEND;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 73, 940U, (void *)

              &chartInstance->c1_is_EEPROM_TRIGGER);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

              (chartInstance->c1_is_EEPROM_TRIGGER == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

              (chartInstance->c1_is_EEPROM_TRIGGER == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 73, 940U, 2);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 5U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_SEND = 1U;

            sf_call_output_fcn_call(chartInstance->S, 13, "eepromTrigger", 0);

          }

        } else {

          _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 6U,

                       chartInstance->c1_sfEvent);

          chartInstance->c1_counterWait++;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 84, 950U, (void *)

            &chartInstance->c1_counterWait);

          _SFD_DATA_RANGE_CHECK(chartInstance->c1_counterWait, 17U);

        }



        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 6U, chartInstance->c1_sfEvent);

        break;



       default:

        CV_STATE_EVAL(4, 0, 0);



        /* Unreachable state, for coverage only */

        chartInstance->c1_is_EEPROM_TRIGGER = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

          (chartInstance->c1_is_EEPROM_TRIGGER == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

          (chartInstance->c1_is_EEPROM_TRIGGER == 2));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 5U, chartInstance->c1_sfEvent);

        break;

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 4U, chartInstance->c1_sfEvent);

    }



    if (chartInstance->c1_is_active_ANTISTALL_ENABLE == 0U) {

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 0U,

                   chartInstance->c1_sfEvent);

      switch (chartInstance->c1_is_ANTISTALL_ENABLE) {

       case c1_IN_DISABLE:

        CV_STATE_EVAL(0, 0, c1_IN_DISABLE);

        *chartInstance->c1_antiStallEnable = 0U;

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 181U,

                     chartInstance->c1_sfEvent);

        c1_i13 = (*chartInstance->c1_antiStall_parameters)[sf_array_bounds_check

          (sfGlobalDebugInstanceStruct, chartInstance->S, 1074U, 1, 20, 34U,

           (int32_T)anti_stall_params_RPM_THRESHOLD, 0, 7)];

        c1_c_out = (CV_TRANSITION_EVAL(181U, (int32_T)_SFD_CCP_CALL(5U, 181U, 0,

          (boolean_T)CV_RELATIONAL_EVAL(5U, 181U, 0, (real_T)c1_i13, 0.0, 0, 1U,

          c1_i13 != 0) != 0U, chartInstance->c1_sfEvent)) != 0);

        if (c1_c_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 181U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_DISABLE = 0U;

          chartInstance->c1_is_ANTISTALL_ENABLE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 77, 1070U, (int32_T)

            (chartInstance->c1_is_ANTISTALL_ENABLE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 78, 1072U, (int32_T)

            (chartInstance->c1_is_ANTISTALL_ENABLE == 2));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 1U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_ANTISTALL_ENABLE == c1_IN_ENABLE) {

          } else {

            chartInstance->c1_is_ANTISTALL_ENABLE = c1_IN_ENABLE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 76, 1069U, (void *)

              &chartInstance->c1_is_ANTISTALL_ENABLE);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 77, 1070U, (int32_T)

              (chartInstance->c1_is_ANTISTALL_ENABLE == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 78, 1072U, (int32_T)

              (chartInstance->c1_is_ANTISTALL_ENABLE == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 76, 1069U, 2);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 2U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ENABLE = 1U;

            *chartInstance->c1_antiStallEnable = 1U;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 14, 1073U, (void *)

              chartInstance->c1_antiStallEnable);

            _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_antiStallEnable,

                                  50U);

          }

        } else {

          _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 1U,

                       chartInstance->c1_sfEvent);

        }



        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c1_sfEvent);

        break;



       case c1_IN_ENABLE:

        CV_STATE_EVAL(0, 0, c1_IN_ENABLE);

        *chartInstance->c1_antiStallEnable = 1U;

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 2U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c1_sfEvent);

        break;



       default:

        CV_STATE_EVAL(0, 0, 0);



        /* Unreachable state, for coverage only */

        chartInstance->c1_is_ANTISTALL_ENABLE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 77, 1070U, (int32_T)

          (chartInstance->c1_is_ANTISTALL_ENABLE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 78, 1072U, (int32_T)

          (chartInstance->c1_is_ANTISTALL_ENABLE == 2));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 1U, chartInstance->c1_sfEvent);

        break;

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);

    }

  }



  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);

}



static void initSimStructsc1_GCU_Model_genCode

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  (void)chartInstance;

}



static void c1_enter_atomic_MANUAL_MODES(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  int32_T c1_i14;

  int32_T c1_i15;

  (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)[0];

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

    chartInstance->c1_lastModeCom);

  for (c1_i14 = 0; c1_i14 < 2; c1_i14++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i14], 48U);

  }



  (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)[1];

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

    chartInstance->c1_lastModeCom);

  for (c1_i15 = 0; c1_i15 < 2; c1_i15++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i15], 48U);

  }



  c1_checkShift(chartInstance);

  c1_checkClutch(chartInstance);

}



static void c1_MANUAL_MODES(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  int32_T c1_i16;

  int32_T c1_i17;

  int32_T c1_i18;

  int32_T c1_i19;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 143U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 143U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 143U, 0,

    (real_T)(*chartInstance->c1_modeCom)[0], (real_T)

    (*chartInstance->c1_lastModeCom)[0], 0, 1U, (*chartInstance->c1_modeCom)[0]

    != (*chartInstance->c1_lastModeCom)[0]) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 143U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U, 143U,

      1, (real_T)(*chartInstance->c1_modeCom)[1], (real_T)

      (*chartInstance->c1_lastModeCom)[1], 0, 1U, (*chartInstance->c1_modeCom)[1]

      != (*chartInstance->c1_lastModeCom)[1]) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(143U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 143U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 145U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 137U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(137U, (int32_T)_SFD_CCP_CALL(5U, 137U, 0,

      ((*chartInstance->c1_modeCom)[1] == ENDURANCE_MODE) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 137U, chartInstance->c1_sfEvent);

      c1_exit_internal_MANUAL_MODES(chartInstance);

      chartInstance->c1_tp_MANUAL_MODES = 0U;

      chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

        (chartInstance->c1_is_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

        (chartInstance->c1_is_MODES == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

        (chartInstance->c1_is_MODES == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

        (chartInstance->c1_is_MODES == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

        (chartInstance->c1_is_MODES == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

        &chartInstance->c1_is_MANUAL_MODES);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

      } else {

        chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

          &chartInstance->c1_is_MODES);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_MANUAL_MODES = 1U;

        c1_enter_atomic_MANUAL_MODES(chartInstance);

      }



      chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

        &chartInstance->c1_is_MANUAL_MODES);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_ENDURANCE = 1U;

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 138U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 139U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(139U, (int32_T)_SFD_CCP_CALL(5U, 139U, 0,

        ((*chartInstance->c1_modeCom)[1] == SKIDPAD_MODE) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 139U, chartInstance->c1_sfEvent);

        c1_exit_internal_MANUAL_MODES(chartInstance);

        chartInstance->c1_tp_MANUAL_MODES = 0U;

        chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

          &chartInstance->c1_is_MANUAL_MODES);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

        } else {

          chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

            &chartInstance->c1_is_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_MANUAL_MODES = 1U;

          c1_enter_atomic_MANUAL_MODES(chartInstance);

        }



        if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

        } else {

          chartInstance->c1_is_MANUAL_MODES = c1_IN_SKIDPAD;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

            &chartInstance->c1_is_MANUAL_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 3);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_SKIDPAD = 1U;

          sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 140U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 141U,

                     chartInstance->c1_sfEvent);

        c1_e_out = (CV_TRANSITION_EVAL(141U, (int32_T)_SFD_CCP_CALL(5U, 141U, 0,

          ((*chartInstance->c1_modeCom)[1] == ACCELERATION_MODE) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 141U, chartInstance->c1_sfEvent);

          c1_exit_internal_MANUAL_MODES(chartInstance);

          chartInstance->c1_tp_MANUAL_MODES = 0U;

          chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 0);

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

            &chartInstance->c1_is_MANUAL_MODES);

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

          } else {

            chartInstance->c1_is_MODES = c1_IN_ACCELERATION;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

              &chartInstance->c1_is_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ACCELERATION = 1U;

            c1_enter_atomic_ACCELERATION(chartInstance);

          }



          c1_enter_internal_ACCELERATION(chartInstance);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 177U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 186U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 185U,

                       chartInstance->c1_sfEvent);

          c1_f_out = (CV_TRANSITION_EVAL(185U, (int32_T)_SFD_CCP_CALL(5U, 185U,

            0, ((*chartInstance->c1_modeCom)[1] == AUTOX_MODE) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_f_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 185U, chartInstance->c1_sfEvent);

            c1_exit_internal_MANUAL_MODES(chartInstance);

            chartInstance->c1_tp_MANUAL_MODES = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_ACCELERATION_PID;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_ACCELERATION_PID = 1U;

              chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

                &chartInstance->c1_lastAutoXCom);

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i17 = 0; c1_i17 < 2; c1_i17++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i17], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i19 = 0; c1_i19 < 2; c1_i19++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i19], 48U);

              }

            }



            c1_enter_internal_ACCELERATION_PID(chartInstance);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 178U, chartInstance->c1_sfEvent);

            c1_exit_internal_MANUAL_MODES(chartInstance);

            chartInstance->c1_tp_MANUAL_MODES = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_MANUAL_MODES = 1U;

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i16 = 0; c1_i16 < 2; c1_i16++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i16], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i18 = 0; c1_i18 < 2; c1_i18++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i18], 48U);

              }



              c1_checkShift(chartInstance);

              c1_checkClutch(chartInstance);

            }



            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 136U, chartInstance->c1_sfEvent);

            chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ENDURANCE = 1U;

          }

        }

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 74U, chartInstance->c1_sfEvent);

    c1_checkShift(chartInstance);

    c1_checkClutch(chartInstance);

    switch (chartInstance->c1_is_MANUAL_MODES) {

     case c1_IN_ENDURANCE:

      CV_STATE_EVAL(74, 0, c1_IN_ENDURANCE);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 75U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 75U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_SKIDPAD:

      CV_STATE_EVAL(74, 0, c1_IN_SKIDPAD);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 76U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 76U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(74, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_MANUAL_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

      break;

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 74U, chartInstance->c1_sfEvent);

}



static void c1_exit_internal_MANUAL_MODES(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_MANUAL_MODES) {

   case c1_IN_ENDURANCE:

    CV_STATE_EVAL(74, 1, c1_IN_ENDURANCE);

    chartInstance->c1_tp_ENDURANCE = 0U;

    chartInstance->c1_is_MANUAL_MODES = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

      (chartInstance->c1_is_MANUAL_MODES == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

      (chartInstance->c1_is_MANUAL_MODES == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_SKIDPAD:

    CV_STATE_EVAL(74, 1, c1_IN_SKIDPAD);

    if (chartInstance->c1_is_MANUAL_MODES != c1_IN_SKIDPAD) {

    } else {

      chartInstance->c1_tp_SKIDPAD = 0U;

      _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG, 76U, chartInstance->c1_sfEvent);

      sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 76U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_MANUAL_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

    }

    break;



   default:

    CV_STATE_EVAL(74, 1, 0);

    chartInstance->c1_is_MANUAL_MODES = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

      (chartInstance->c1_is_MANUAL_MODES == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

      (chartInstance->c1_is_MANUAL_MODES == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_INIT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i20;

  boolean_T c1_covSaturation;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  int32_T c1_i21;

  int32_T c1_i22;

  int32_T c1_i23;

  int32_T c1_i24;

  int32_T c1_i25;

  int32_T c1_i26;

  int32_T c1_i27;

  int32_T c1_i28;

  int32_T c1_i29;

  int32_T c1_i30;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 79U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(79U, (int32_T)_SFD_CCP_CALL(5U, 79U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 79U, 0, (real_T)

    chartInstance->c1_buzzerCounter, 1000.0, 0, 5U,

    chartInstance->c1_buzzerCounter >= 1000) != 0U, chartInstance->c1_sfEvent))

              != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 79U, chartInstance->c1_sfEvent);

    sf_call_output_fcn_call(chartInstance->S, 15, "BuzzerOff", 0);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 137U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(137U, (int32_T)_SFD_CCP_CALL(5U, 137U, 0,

      ((*chartInstance->c1_modeCom)[1] == ENDURANCE_MODE) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 137U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_INIT = 0U;

      chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

        (chartInstance->c1_is_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

        (chartInstance->c1_is_MODES == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

        (chartInstance->c1_is_MODES == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

        (chartInstance->c1_is_MODES == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

        (chartInstance->c1_is_MODES == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

      } else {

        chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

          &chartInstance->c1_is_MODES);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_MANUAL_MODES = 1U;

        (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)[0];

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

          chartInstance->c1_lastModeCom);

        for (c1_i21 = 0; c1_i21 < 2; c1_i21++) {

          _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i21],

                                48U);

        }



        (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)[1];

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

          chartInstance->c1_lastModeCom);

        for (c1_i23 = 0; c1_i23 < 2; c1_i23++) {

          _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i23],

                                48U);

        }



        c1_checkShift(chartInstance);

        c1_checkClutch(chartInstance);

      }



      chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

        &chartInstance->c1_is_MANUAL_MODES);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_ENDURANCE = 1U;

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 138U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 139U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(139U, (int32_T)_SFD_CCP_CALL(5U, 139U, 0,

        ((*chartInstance->c1_modeCom)[1] == SKIDPAD_MODE) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 139U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_INIT = 0U;

        chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

        } else {

          chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

            &chartInstance->c1_is_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_MANUAL_MODES = 1U;

          (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)[0];

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

            chartInstance->c1_lastModeCom);

          for (c1_i22 = 0; c1_i22 < 2; c1_i22++) {

            _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                  [c1_i22], 48U);

          }



          (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)[1];

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

            chartInstance->c1_lastModeCom);

          for (c1_i24 = 0; c1_i24 < 2; c1_i24++) {

            _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                  [c1_i24], 48U);

          }



          c1_checkShift(chartInstance);

          c1_checkClutch(chartInstance);

        }



        if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

        } else {

          chartInstance->c1_is_MANUAL_MODES = c1_IN_SKIDPAD;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

            &chartInstance->c1_is_MANUAL_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 3);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_SKIDPAD = 1U;

          sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 140U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 141U,

                     chartInstance->c1_sfEvent);

        c1_e_out = (CV_TRANSITION_EVAL(141U, (int32_T)_SFD_CCP_CALL(5U, 141U, 0,

          ((*chartInstance->c1_modeCom)[1] == ACCELERATION_MODE) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 141U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_INIT = 0U;

          chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

          } else {

            chartInstance->c1_is_MODES = c1_IN_ACCELERATION;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

              &chartInstance->c1_is_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ACCELERATION = 1U;

            chartInstance->c1_lastAacCom = (*chartInstance->c1_aacCom)[0];

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

              &chartInstance->c1_lastAacCom);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

            (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)[0];

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

              chartInstance->c1_lastModeCom);

            for (c1_i25 = 0; c1_i25 < 2; c1_i25++) {

              _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                    [c1_i25], 48U);

            }



            (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)[1];

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

              chartInstance->c1_lastModeCom);

            for (c1_i28 = 0; c1_i28 < 2; c1_i28++) {

              _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                    [c1_i28], 48U);

            }

          }



          c1_enter_internal_ACCELERATION(chartInstance);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 177U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 186U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 185U,

                       chartInstance->c1_sfEvent);

          c1_f_out = (CV_TRANSITION_EVAL(185U, (int32_T)_SFD_CCP_CALL(5U, 185U,

            0, ((*chartInstance->c1_modeCom)[1] == AUTOX_MODE) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_f_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 185U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_INIT = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_ACCELERATION_PID;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_ACCELERATION_PID = 1U;

              chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

                &chartInstance->c1_lastAutoXCom);

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i27 = 0; c1_i27 < 2; c1_i27++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i27], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i30 = 0; c1_i30 < 2; c1_i30++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i30], 48U);

              }

            }



            c1_enter_internal_ACCELERATION_PID(chartInstance);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 178U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_INIT = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_MANUAL_MODES = 1U;

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i26 = 0; c1_i26 < 2; c1_i26++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i26], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i29 = 0; c1_i29 < 2; c1_i29++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i29], 48U);

              }



              c1_checkShift(chartInstance);

              c1_checkClutch(chartInstance);

            }



            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 136U, chartInstance->c1_sfEvent);

            chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ENDURANCE = 1U;

          }

        }

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 73U, chartInstance->c1_sfEvent);

    c1_i20 = c1__s32_add__(chartInstance, (int32_T)

      chartInstance->c1_buzzerCounter, 1, 429U, 38, 15);

    c1_covSaturation = false;

    if (c1_i20 < 0) {

      c1_covSaturation = true;

      c1_i20 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 429U, 38U, 15U);

    } else {

      if (c1_i20 > 65535) {

        c1_i20 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 429U, 38U, 15U);

      }



      CV_SATURATION_EVAL(4, 73, 0, 0, c1_covSaturation);

    }



    chartInstance->c1_buzzerCounter = (uint16_T)c1_i20;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 34, 1063U, (void *)

      &chartInstance->c1_buzzerCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_buzzerCounter, 0U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 73U, chartInstance->c1_sfEvent);

}



static void c1_enter_atomic_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  int32_T c1_i31;

  int32_T c1_i32;

  chartInstance->c1_lastAacCom = (*chartInstance->c1_aacCom)[0];

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

    &chartInstance->c1_lastAacCom);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

  (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)[0];

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

    chartInstance->c1_lastModeCom);

  for (c1_i31 = 0; c1_i31 < 2; c1_i31++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i31], 48U);

  }



  (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)[1];

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

    chartInstance->c1_lastModeCom);

  for (c1_i32 = 0; c1_i32 < 2; c1_i32++) {

    _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)[c1_i32], 48U);

  }

}



static void c1_enter_internal_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct *

  chartInstance)

{

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 142U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_ACCELERATION == c1_IN_DEFAULT) {

  } else {

    chartInstance->c1_is_ACCELERATION = c1_IN_DEFAULT;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

      &chartInstance->c1_is_ACCELERATION);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 4);

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 47U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_DEFAULT = 1U;

    *chartInstance->c1_stateFb = (uint16_T)ACC_OFF;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_checkShift(chartInstance);

    c1_checkClutch(chartInstance);

  }

}



static void c1_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  int32_T c1_i33;

  int32_T c1_i34;

  int32_T c1_i35;

  int32_T c1_i36;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 144U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 144U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 144U, 0,

    (real_T)(*chartInstance->c1_modeCom)[0], (real_T)

    (*chartInstance->c1_lastModeCom)[0], 0, 1U, (*chartInstance->c1_modeCom)[0]

    != (*chartInstance->c1_lastModeCom)[0]) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 144U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U, 144U,

      1, (real_T)(*chartInstance->c1_modeCom)[1], (real_T)

      (*chartInstance->c1_lastModeCom)[1], 0, 1U, (*chartInstance->c1_modeCom)[1]

      != (*chartInstance->c1_lastModeCom)[1]) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(144U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 144U, chartInstance->c1_sfEvent);

    sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

    *chartInstance->c1_stateFb = (uint16_T)ACC_OFF;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_Clutch_setValue(chartInstance, 0U);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 145U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 137U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(137U, (int32_T)_SFD_CCP_CALL(5U, 137U, 0,

      ((*chartInstance->c1_modeCom)[1] == ENDURANCE_MODE) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 137U, chartInstance->c1_sfEvent);

      c1_exit_internal_ACCELERATION(chartInstance);

      chartInstance->c1_tp_ACCELERATION = 0U;

      chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

        (chartInstance->c1_is_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

        (chartInstance->c1_is_MODES == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

        (chartInstance->c1_is_MODES == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

        (chartInstance->c1_is_MODES == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

        (chartInstance->c1_is_MODES == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

        &chartInstance->c1_is_ACCELERATION);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

      } else {

        chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

          &chartInstance->c1_is_MODES);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_MANUAL_MODES = 1U;

        c1_enter_atomic_MANUAL_MODES(chartInstance);

      }



      chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

        &chartInstance->c1_is_MANUAL_MODES);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_ENDURANCE = 1U;

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 138U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 139U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(139U, (int32_T)_SFD_CCP_CALL(5U, 139U, 0,

        ((*chartInstance->c1_modeCom)[1] == SKIDPAD_MODE) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 139U, chartInstance->c1_sfEvent);

        c1_exit_internal_ACCELERATION(chartInstance);

        chartInstance->c1_tp_ACCELERATION = 0U;

        chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

          &chartInstance->c1_is_ACCELERATION);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

        } else {

          chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

            &chartInstance->c1_is_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_MANUAL_MODES = 1U;

          c1_enter_atomic_MANUAL_MODES(chartInstance);

        }



        if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

        } else {

          chartInstance->c1_is_MANUAL_MODES = c1_IN_SKIDPAD;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

            &chartInstance->c1_is_MANUAL_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 3);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_SKIDPAD = 1U;

          sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 140U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 141U,

                     chartInstance->c1_sfEvent);

        c1_e_out = (CV_TRANSITION_EVAL(141U, (int32_T)_SFD_CCP_CALL(5U, 141U, 0,

          ((*chartInstance->c1_modeCom)[1] == ACCELERATION_MODE) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 141U, chartInstance->c1_sfEvent);

          c1_exit_internal_ACCELERATION(chartInstance);

          chartInstance->c1_tp_ACCELERATION = 0U;

          chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

            &chartInstance->c1_is_ACCELERATION);

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

          } else {

            chartInstance->c1_is_MODES = c1_IN_ACCELERATION;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

              &chartInstance->c1_is_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ACCELERATION = 1U;

            c1_enter_atomic_ACCELERATION(chartInstance);

          }



          c1_enter_internal_ACCELERATION(chartInstance);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 177U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 186U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 185U,

                       chartInstance->c1_sfEvent);

          c1_f_out = (CV_TRANSITION_EVAL(185U, (int32_T)_SFD_CCP_CALL(5U, 185U,

            0, ((*chartInstance->c1_modeCom)[1] == AUTOX_MODE) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_f_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 185U, chartInstance->c1_sfEvent);

            c1_exit_internal_ACCELERATION(chartInstance);

            chartInstance->c1_tp_ACCELERATION = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

              &chartInstance->c1_is_ACCELERATION);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_ACCELERATION_PID;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_ACCELERATION_PID = 1U;

              chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

                &chartInstance->c1_lastAutoXCom);

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i34 = 0; c1_i34 < 2; c1_i34++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i34], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i36 = 0; c1_i36 < 2; c1_i36++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i36], 48U);

              }

            }



            c1_enter_internal_ACCELERATION_PID(chartInstance);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 178U, chartInstance->c1_sfEvent);

            c1_exit_internal_ACCELERATION(chartInstance);

            chartInstance->c1_tp_ACCELERATION = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

              &chartInstance->c1_is_ACCELERATION);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_MANUAL_MODES = 1U;

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i33 = 0; c1_i33 < 2; c1_i33++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i33], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i35 = 0; c1_i35 < 2; c1_i35++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i35], 48U);

              }



              c1_checkShift(chartInstance);

              c1_checkClutch(chartInstance);

            }



            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 136U, chartInstance->c1_sfEvent);

            chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ENDURANCE = 1U;

          }

        }

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 36U, chartInstance->c1_sfEvent);

    switch (chartInstance->c1_is_ACCELERATION) {

     case c1_IN_ACC:

      CV_STATE_EVAL(36, 0, c1_IN_ACC);

      c1_ACC(chartInstance);

      break;



     case c1_IN_DEFAULT:

      CV_STATE_EVAL(36, 0, c1_IN_DEFAULT);

      c1_DEFAULT(chartInstance);

      break;



     default:

      CV_STATE_EVAL(36, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

        (chartInstance->c1_is_ACCELERATION == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

        (chartInstance->c1_is_ACCELERATION == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

      break;

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 36U, chartInstance->c1_sfEvent);

}



static void c1_exit_internal_ACCELERATION(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_ACCELERATION) {

   case c1_IN_ACC:

    CV_STATE_EVAL(36, 1, c1_IN_ACC);

    switch (chartInstance->c1_is_ACC) {

     case c1_IN_ACTIVE:

      CV_STATE_EVAL(37, 1, c1_IN_ACTIVE);

      c1_exit_internal_ACTIVE(chartInstance);

      chartInstance->c1_tp_ACTIVE = 0U;

      chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

        (chartInstance->c1_is_ACC == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

        (chartInstance->c1_is_ACC == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

        &chartInstance->c1_is_ACTIVE);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_STOPPING:

      CV_STATE_EVAL(37, 1, c1_IN_STOPPING);

      chartInstance->c1_tp_STOPPING = 0U;

      chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

        (chartInstance->c1_is_ACC == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

        (chartInstance->c1_is_ACC == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 45U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(37, 1, 0);

      chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

        (chartInstance->c1_is_ACC == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

        (chartInstance->c1_is_ACC == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

      break;

    }



    chartInstance->c1_tp_ACC = 0U;

    chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

      &chartInstance->c1_is_ACC);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_DEFAULT:

    CV_STATE_EVAL(36, 1, c1_IN_DEFAULT);

    chartInstance->c1_tp_DEFAULT = 0U;

    chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 47U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(36, 1, 0);

    chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_ACC(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 37U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_ACC) {

   case c1_IN_ACTIVE:

    CV_STATE_EVAL(37, 0, c1_IN_ACTIVE);

    c1_ACTIVE(chartInstance);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 37U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_STOPPING:

    CV_STATE_EVAL(37, 0, c1_IN_STOPPING);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 120U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_STOPPING = 0U;

    chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

      (chartInstance->c1_is_ACC == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

      (chartInstance->c1_is_ACC == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 45U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_ACC = 0U;

    chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

      &chartInstance->c1_is_ACC);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACCELERATION == c1_IN_DEFAULT) {

    } else {

      chartInstance->c1_is_ACCELERATION = c1_IN_DEFAULT;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

        &chartInstance->c1_is_ACCELERATION);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

        (chartInstance->c1_is_ACCELERATION == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

        (chartInstance->c1_is_ACCELERATION == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 4);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 47U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_DEFAULT = 1U;

      *chartInstance->c1_stateFb = (uint16_T)ACC_OFF;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

        chartInstance->c1_stateFb);

      _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

      c1_checkShift(chartInstance);

      c1_checkClutch(chartInstance);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 45U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACCELERATION != c1_IN_ACC) {

    } else {

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 37U, chartInstance->c1_sfEvent);

    }

    break;



   default:

    CV_STATE_EVAL(37, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

      (chartInstance->c1_is_ACC == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

      (chartInstance->c1_is_ACC == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 37U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  int32_T c1_i37;

  uint16_T c1_u0;

  boolean_T c1_b_temp;

  int32_T c1_i38;

  boolean_T c1_covSaturation;

  boolean_T c1_c_temp;

  boolean_T c1_d_out;

  boolean_T c1_d_temp;

  int32_T c1_i39;

  boolean_T c1_e_out;

  real_T c1_d0;

  boolean_T c1_b_covSaturation;

  uint8_T c1_u1;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_c_covSaturation;

  int32_T c1_qY;

  int64_T c1_i40;

  boolean_T c1_d_covSaturation;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 100U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 100U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 100U, 0,

    (real_T)(*chartInstance->c1_aacCom)[0], (real_T)chartInstance->c1_lastAacCom,

    0, 1U, (*chartInstance->c1_aacCom)[0] != chartInstance->c1_lastAacCom) != 0U,

    chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 100U, 1, ((*chartInstance->c1_aacCom)[1] ==

      ACC_OFF) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(100U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 100U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastAacCom = (*chartInstance->c1_aacCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

      &chartInstance->c1_lastAacCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

    c1_u0 = chartInstance->c1_lastAacCom;

    sf_mex_printf("%s =\\n", "lastAacCom");

    sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u0);

    c1_exit_internal_ACTIVE(chartInstance);

    chartInstance->c1_tp_ACTIVE = 0U;

    chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

      (chartInstance->c1_is_ACC == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

      (chartInstance->c1_is_ACC == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

      &chartInstance->c1_is_ACTIVE);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACC == c1_IN_STOPPING) {

    } else {

      chartInstance->c1_is_ACC = c1_IN_STOPPING;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

        &chartInstance->c1_is_ACC);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

        (chartInstance->c1_is_ACC == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

        (chartInstance->c1_is_ACC == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 24);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 7);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 6);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 45U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_STOPPING = 1U;

      sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

      c1_Clutch_setValue(chartInstance, 0U);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

    switch (chartInstance->c1_is_ACTIVE) {

     case c1_IN_READY:

      CV_STATE_EVAL(38, 0, c1_IN_READY);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 106U,

                   chartInstance->c1_sfEvent);

      c1_c_out = (CV_TRANSITION_EVAL(106U, (int32_T)_SFD_CCP_CALL(5U, 106U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 106U, 0, (real_T)

        chartInstance->c1_aacCounter, 1.0, 0, 3U, chartInstance->c1_aacCounter <=

        1) != 0U, chartInstance->c1_sfEvent)) != 0);

      if (c1_c_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 106U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 101U,

                     chartInstance->c1_sfEvent);

        c1_c_temp = _SFD_CCP_CALL(5U, 101U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U,

          101U, 0, (real_T)(*chartInstance->c1_aacCom)[0], (real_T)

          chartInstance->c1_lastAacCom, 0, 1U, (*chartInstance->c1_aacCom)[0] !=

          chartInstance->c1_lastAacCom) != 0U, chartInstance->c1_sfEvent);

        if (c1_c_temp) {

          c1_c_temp = _SFD_CCP_CALL(5U, 101U, 1, ((*chartInstance->c1_aacCom)[1]

            == ACC_GO) != 0U, chartInstance->c1_sfEvent);

        }



        c1_d_temp = c1_c_temp;

        if (c1_d_temp) {

          c1_i39 = c1_getAacParam(chartInstance, acc_params_TPS_START_LIMIT);

          c1_d_temp = _SFD_CCP_CALL(5U, 101U, 2, (boolean_T)CV_RELATIONAL_EVAL

            (5U, 101U, 1, (real_T)*chartInstance->c1_currTps, (real_T)c1_i39, 0,

             5U, *chartInstance->c1_currTps >= c1_i39) != 0U,

            chartInstance->c1_sfEvent);

        }



        c1_e_out = (CV_TRANSITION_EVAL(101U, (int32_T)c1_d_temp) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 101U, chartInstance->c1_sfEvent);

          chartInstance->c1_lastAacCom = (*chartInstance->c1_aacCom)[0];

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

            &chartInstance->c1_lastAacCom);

          _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

          chartInstance->c1_tp_READY = 0U;

          chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 5));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_ACTIVE == c1_IN_START_RELEASE) {

          } else {

            chartInstance->c1_is_ACTIVE = c1_IN_START_RELEASE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

              &chartInstance->c1_is_ACTIVE);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 21);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 4);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 3);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 3);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 43U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_START_RELEASE = 1U;

            *chartInstance->c1_stateFb = (uint16_T)ACC_GO;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

              chartInstance->c1_stateFb);

            _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

            chartInstance->c1_aac_clutchValue = (real_T)c1_getAacParam

              (chartInstance, acc_params_RAMP_START);

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 45, 561U, (void *)

              &chartInstance->c1_aac_clutchValue);

            _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchValue, 6U);

            c1_d0 = chartInstance->c1_aac_clutchValue;

            c1_b_covSaturation = false;

            if (c1_d0 < 256.0) {

              if (c1_d0 >= 0.0) {

                c1_u1 = (uint8_T)c1_d0;

              } else {

                c1_b_covSaturation = true;

                c1_u1 = 0U;

                _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 120U, 5U);

              }

            } else if (c1_d0 >= 256.0) {

              c1_b_covSaturation = true;

              c1_u1 = MAX_uint8_T;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 120U, 5U);

            } else {

              c1_u1 = 0U;

            }



            CV_SATURATION_EVAL(4, 43, 0, 0, c1_b_covSaturation);

            c1_Clutch_setValue(chartInstance, c1_u1);

            chartInstance->c1_aac_dtRelease = c1_div_nzp_s32(chartInstance,

              c1_getAacParam(chartInstance, acc_params_RAMP_TIME), (int32_T)

              c1_const_AAC_WORK_RATE_ms, 547U, 196, 1);

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 47, 564U, (void *)

              &chartInstance->c1_aac_dtRelease);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aac_dtRelease, 7U);

            c1_q0 = c1_getAacParam(chartInstance, acc_params_RAMP_START);

            c1_q1 = c1_getAacParam(chartInstance, acc_params_RAMP_END);

            c1_c_covSaturation = false;

            if ((c1_q0 >= 0) && (c1_q1 < c1_q0 - MAX_int32_T)) {

              c1_c_covSaturation = true;

              c1_qY = MAX_int32_T;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 284U, 1U);

            } else if ((c1_q0 < 0) && (c1_q1 > c1_q0 - MIN_int32_T)) {

              c1_c_covSaturation = true;

              c1_qY = MIN_int32_T;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 284U, 1U);

            } else {

              c1_qY = c1_q0 - c1_q1;

            }



            CV_SATURATION_EVAL(4, 43, 1, 0, c1_c_covSaturation);

            c1_i40 = (int64_T)c1_qY * (int64_T)c1_const_AAC_WORK_RATE_ms;

            c1_d_covSaturation = false;

            if (c1_i40 > 2147483647LL) {

              c1_d_covSaturation = true;

              c1_i40 = 2147483647LL;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 320U, 1U);

            } else {

              if (c1_i40 < -2147483648LL) {

                c1_d_covSaturation = true;

                c1_i40 = -2147483648LL;

                _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 320U, 1U);

              }

            }



            CV_SATURATION_EVAL(4, 43, 2, 0, c1_d_covSaturation);

            chartInstance->c1_aac_clutchStep = (real_T)(int32_T)c1_i40 / (real_T)

              c1_getAacParam(chartInstance, acc_params_RAMP_TIME);

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 46, 563U, (void *)

              &chartInstance->c1_aac_clutchStep);

            _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchStep, 5U);

            chartInstance->c1_aacCounter = c1_const_AAC_WORK_RATE_ms;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

              &chartInstance->c1_aacCounter);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

          }

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 107U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_READY = 0U;

          chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

            (chartInstance->c1_is_ACTIVE == 5));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_ACTIVE == c1_IN_READY) {

          } else {

            chartInstance->c1_is_ACTIVE = c1_IN_READY;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

              &chartInstance->c1_is_ACTIVE);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

              (chartInstance->c1_is_ACTIVE == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 20);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 3);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 2);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_READY = 1U;

            c1_enter_atomic_READY(chartInstance);

          }

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 39U,

                     chartInstance->c1_sfEvent);

        c1_i38 = c1__s32_minus__(chartInstance, (int32_T)

          chartInstance->c1_aacCounter, 1, 545U, 129, 1);

        c1_covSaturation = false;

        if (c1_i38 < 0) {

          c1_covSaturation = true;

          c1_i38 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 545U, 129U, 1U);

        } else {

          if (c1_i38 > 65535) {

            c1_i38 = 65535;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 545U, 129U, 1U);

          }



          CV_SATURATION_EVAL(4, 39, 0, 0, c1_covSaturation);

        }



        chartInstance->c1_aacCounter = (uint16_T)c1_i38;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

          &chartInstance->c1_aacCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

        c1_checkShift(chartInstance);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 39U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_RELEASING:

      CV_STATE_EVAL(38, 0, c1_IN_RELEASING);

      c1_RELEASING(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_RUNNING:

      CV_STATE_EVAL(38, 0, c1_IN_RUNNING);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 111U,

                   chartInstance->c1_sfEvent);

      c1_i37 = (*chartInstance->c1_acc_parameters)[(uint8_T)

        sf_array_bounds_check(sfGlobalDebugInstanceStruct, chartInstance->S,

        577U, 13, 14, 29U, (int32_T)c1__u8_s32_(chartInstance, (int32_T)

        acc_params_END_GEAR, 577U, 13, 14), 0, 15)];

      c1_b_temp = _SFD_CCP_CALL(5U, 111U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U,

        111U, 0, (real_T)*chartInstance->c1_currGear, (real_T)c1_i37, 0, 5U,

        *chartInstance->c1_currGear >= c1_i37) != 0U, chartInstance->c1_sfEvent);

      if (c1_b_temp) {

        c1_b_temp = _SFD_CCP_CALL(5U, 111U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

          111U, 1, (real_T)*chartInstance->c1_currGear, 8.0, 0, 1U,

          *chartInstance->c1_currGear != 8) != 0U, chartInstance->c1_sfEvent);

      }



      c1_d_out = (CV_TRANSITION_EVAL(111U, (int32_T)c1_b_temp) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 111U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_RUNNING = 0U;

        chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 41U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_ACTIVE = 0U;

        chartInstance->c1_is_ACC = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

          (chartInstance->c1_is_ACC == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

          (chartInstance->c1_is_ACC == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

          &chartInstance->c1_is_ACTIVE);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_ACC == c1_IN_STOPPING) {

        } else {

          chartInstance->c1_is_ACC = c1_IN_STOPPING;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

            &chartInstance->c1_is_ACC);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

            (chartInstance->c1_is_ACC == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

            (chartInstance->c1_is_ACC == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 24);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 7);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 6);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 45U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_STOPPING = 1U;

          sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

          c1_Clutch_setValue(chartInstance, 0U);

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 41U,

                     chartInstance->c1_sfEvent);

        c1_aacCheckShift(chartInstance);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 41U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_ACC != c1_IN_ACTIVE) {

      } else {

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

      }

      break;



     case c1_IN_START:

      CV_STATE_EVAL(38, 0, c1_IN_START);

      c1_START(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_START_RELEASE:

      CV_STATE_EVAL(38, 0, c1_IN_START_RELEASE);

      c1_START_RELEASE(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(38, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c1_sfEvent);

      break;

    }

  }

}



static void c1_exit_internal_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_ACTIVE) {

   case c1_IN_READY:

    CV_STATE_EVAL(38, 1, c1_IN_READY);

    chartInstance->c1_tp_READY = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_RELEASING:

    CV_STATE_EVAL(38, 1, c1_IN_RELEASING);

    chartInstance->c1_tp_RELEASING = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_RUNNING:

    CV_STATE_EVAL(38, 1, c1_IN_RUNNING);

    chartInstance->c1_tp_RUNNING = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 41U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_START:

    CV_STATE_EVAL(38, 1, c1_IN_START);

    chartInstance->c1_tp_START = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 42U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_START_RELEASE:

    CV_STATE_EVAL(38, 1, c1_IN_START_RELEASE);

    chartInstance->c1_tp_START_RELEASE = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 43U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(38, 1, 0);

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i41;

  boolean_T c1_covSaturation;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 103U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(103U, (int32_T)_SFD_CCP_CALL(5U, 103U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 103U, 0, (real_T)

    chartInstance->c1_aacCounter, 1.0, 0, 3U, chartInstance->c1_aacCounter <= 1)

    != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 103U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_START = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 42U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACTIVE == c1_IN_READY) {

    } else {

      chartInstance->c1_is_ACTIVE = c1_IN_READY;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

        &chartInstance->c1_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 20);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 3);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 2);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_READY = 1U;

      c1_enter_atomic_READY(chartInstance);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 42U, chartInstance->c1_sfEvent);

    c1_i41 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_aacCounter, 1, 543U, 155, 1);

    c1_covSaturation = false;

    if (c1_i41 < 0) {

      c1_covSaturation = true;

      c1_i41 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 543U, 155U, 1U);

    } else {

      if (c1_i41 > 65535) {

        c1_i41 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 543U, 155U, 1U);

      }



      CV_SATURATION_EVAL(4, 42, 0, 0, c1_covSaturation);

    }



    chartInstance->c1_aacCounter = (uint16_T)c1_i41;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

      &chartInstance->c1_aacCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 42U, chartInstance->c1_sfEvent);

}



static void c1_enter_atomic_READY(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  uint16_T c1_u2;

  *chartInstance->c1_stateFb = (uint16_T)ACC_READY;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

    chartInstance->c1_stateFb);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

  chartInstance->c1_aacCounter = c1_const_AAC_WORK_RATE_ms;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

    &chartInstance->c1_aacCounter);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

  c1_u2 = chartInstance->c1_aacCounter;

  sf_mex_printf("%s =\\n", "aacCounter");

  sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u2);

  c1_Clutch_setValue(chartInstance, 100U);

  c1_checkShift(chartInstance);

}



static void c1_START_RELEASE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i42;

  boolean_T c1_covSaturation;

  real_T c1_d1;

  boolean_T c1_b_covSaturation;

  uint8_T c1_u3;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_c_covSaturation;

  int32_T c1_qY;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 102U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(102U, (int32_T)_SFD_CCP_CALL(5U, 102U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 102U, 0, (real_T)

    chartInstance->c1_aacCounter, 1.0, 0, 3U, chartInstance->c1_aacCounter <= 1)

    != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 102U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_START_RELEASE = 0U;

    chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

      (chartInstance->c1_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 43U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACTIVE == c1_IN_RELEASING) {

    } else {

      chartInstance->c1_is_ACTIVE = c1_IN_RELEASING;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

        &chartInstance->c1_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 22);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 5);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 4);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 4);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_RELEASING = 1U;

      chartInstance->c1_aac_clutchValue -= chartInstance->c1_aac_clutchStep;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 45, 561U, (void *)

        &chartInstance->c1_aac_clutchValue);

      _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchValue, 6U);

      c1_d1 = chartInstance->c1_aac_clutchValue;

      c1_b_covSaturation = false;

      if (c1_d1 < 256.0) {

        if (c1_d1 >= 0.0) {

          c1_u3 = (uint8_T)c1_d1;

        } else {

          c1_b_covSaturation = true;

          c1_u3 = 0U;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 87U, 5U);

        }

      } else if (c1_d1 >= 256.0) {

        c1_b_covSaturation = true;

        c1_u3 = MAX_uint8_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 87U, 5U);

      } else {

        c1_u3 = 0U;

      }



      CV_SATURATION_EVAL(4, 40, 2, 0, c1_b_covSaturation);

      c1_Clutch_setValue(chartInstance, c1_u3);

      c1_q0 = chartInstance->c1_aac_dtRelease;

      c1_q1 = 1;

      c1_c_covSaturation = false;

      if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

        c1_c_covSaturation = true;

        c1_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 143U, 1U);

      } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

        c1_c_covSaturation = true;

        c1_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 143U, 1U);

      } else {

        c1_qY = c1_q0 - c1_q1;

      }



      CV_SATURATION_EVAL(4, 40, 0, 0, c1_c_covSaturation);

      chartInstance->c1_aac_dtRelease = c1_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 47, 564U, (void *)

        &chartInstance->c1_aac_dtRelease);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aac_dtRelease, 7U);

      chartInstance->c1_aacCounter = c1_const_AAC_WORK_RATE_ms;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

        &chartInstance->c1_aacCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 43U, chartInstance->c1_sfEvent);

    c1_i42 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_aacCounter, 1, 547U, 457, 1);

    c1_covSaturation = false;

    if (c1_i42 < 0) {

      c1_covSaturation = true;

      c1_i42 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 457U, 1U);

    } else {

      if (c1_i42 > 65535) {

        c1_i42 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 547U, 457U, 1U);

      }



      CV_SATURATION_EVAL(4, 43, 3, 0, c1_covSaturation);

    }



    chartInstance->c1_aacCounter = (uint16_T)c1_i42;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

      &chartInstance->c1_aacCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 43U, chartInstance->c1_sfEvent);

}



static void c1_RELEASING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i43;

  boolean_T c1_covSaturation;

  boolean_T c1_temp;

  int32_T c1_i44;

  boolean_T c1_c_out;

  real_T c1_d2;

  boolean_T c1_b_covSaturation;

  uint16_T c1_u4;

  uint8_T c1_u5;

  uint16_T c1_u6;

  boolean_T c1_c_covSaturation;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_d_covSaturation;

  int32_T c1_qY;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 104U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(104U, (int32_T)_SFD_CCP_CALL(5U, 104U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 104U, 0, (real_T)

    chartInstance->c1_aacCounter, 1.0, 0, 3U, chartInstance->c1_aacCounter <= 1)

    != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 104U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 110U,

                 chartInstance->c1_sfEvent);

    c1_temp = _SFD_CCP_CALL(5U, 110U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 110U,

      0, (real_T)chartInstance->c1_aac_dtRelease, 0.0, 0, 3U,

      chartInstance->c1_aac_dtRelease <= 0) != 0U, chartInstance->c1_sfEvent);

    if (!c1_temp) {

      c1_i44 = c1_getAacParam(chartInstance, acc_params_RAMP_END);

      c1_temp = _SFD_CCP_CALL(5U, 110U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

        110U, 1, (real_T)*chartInstance->c1_clutchCurrVal, (real_T)c1_i44, 0, 3U,

        *chartInstance->c1_clutchCurrVal <= c1_i44) != 0U,

        chartInstance->c1_sfEvent);

    }



    c1_c_out = (CV_TRANSITION_EVAL(110U, (int32_T)c1_temp) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 110U, chartInstance->c1_sfEvent);

      c1_Clutch_setValue(chartInstance, 0U);

      sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

      chartInstance->c1_tp_RELEASING = 0U;

      chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_ACTIVE == c1_IN_RUNNING) {

      } else {

        chartInstance->c1_is_ACTIVE = c1_IN_RUNNING;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

          &chartInstance->c1_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 23);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 6);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 5);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 5);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 41U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_RUNNING = 1U;

        chartInstance->c1_aacCounter = c1_const_AAC_WORK_RATE_ms;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

          &chartInstance->c1_aacCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

        c1_u4 = chartInstance->c1_aacCounter;

        sf_mex_printf("%s =\\n", "aacCounter");

        sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u4);

        c1_u6 = *chartInstance->c1_currGear;

        c1_c_covSaturation = false;

        if (c1_u6 > 255) {

          c1_c_covSaturation = true;

          c1_u6 = 255U;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 514U, 60U, 8U);

        }



        CV_SATURATION_EVAL(4, 41, 0, 0, c1_c_covSaturation);

        chartInstance->c1_lastShift = (uint8_T)c1_u6;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

          &chartInstance->c1_lastShift);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

        c1_aacCheckShift(chartInstance);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 112U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_RELEASING = 0U;

      chartInstance->c1_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_ACTIVE == c1_IN_RELEASING) {

      } else {

        chartInstance->c1_is_ACTIVE = c1_IN_RELEASING;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

          &chartInstance->c1_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

          (chartInstance->c1_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 22);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 5);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 4);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 4);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_RELEASING = 1U;

        chartInstance->c1_aac_clutchValue -= chartInstance->c1_aac_clutchStep;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 45, 561U, (void *)

          &chartInstance->c1_aac_clutchValue);

        _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchValue, 6U);

        c1_d2 = chartInstance->c1_aac_clutchValue;

        c1_b_covSaturation = false;

        if (c1_d2 < 256.0) {

          if (c1_d2 >= 0.0) {

            c1_u5 = (uint8_T)c1_d2;

          } else {

            c1_b_covSaturation = true;

            c1_u5 = 0U;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 87U, 5U);

          }

        } else if (c1_d2 >= 256.0) {

          c1_b_covSaturation = true;

          c1_u5 = MAX_uint8_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 87U, 5U);

        } else {

          c1_u5 = 0U;

        }



        CV_SATURATION_EVAL(4, 40, 2, 0, c1_b_covSaturation);

        c1_Clutch_setValue(chartInstance, c1_u5);

        c1_q0 = chartInstance->c1_aac_dtRelease;

        c1_q1 = 1;

        c1_d_covSaturation = false;

        if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

          c1_d_covSaturation = true;

          c1_qY = MAX_int32_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 143U, 1U);

        } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

          c1_d_covSaturation = true;

          c1_qY = MIN_int32_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 143U, 1U);

        } else {

          c1_qY = c1_q0 - c1_q1;

        }



        CV_SATURATION_EVAL(4, 40, 0, 0, c1_d_covSaturation);

        chartInstance->c1_aac_dtRelease = c1_qY;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 47, 564U, (void *)

          &chartInstance->c1_aac_dtRelease);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aac_dtRelease, 7U);

        chartInstance->c1_aacCounter = c1_const_AAC_WORK_RATE_ms;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

          &chartInstance->c1_aacCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 40U, chartInstance->c1_sfEvent);

    c1_i43 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_aacCounter, 1, 544U, 213, 1);

    c1_covSaturation = false;

    if (c1_i43 < 0) {

      c1_covSaturation = true;

      c1_i43 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 213U, 1U);

    } else {

      if (c1_i43 > 65535) {

        c1_i43 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 544U, 213U, 1U);

      }



      CV_SATURATION_EVAL(4, 40, 1, 0, c1_covSaturation);

    }



    chartInstance->c1_aacCounter = (uint16_T)c1_i43;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

      &chartInstance->c1_aacCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 40U, chartInstance->c1_sfEvent);

}



static void c1_DEFAULT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  uint16_T c1_u7;

  uint16_T c1_u8;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 121U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 121U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 121U, 0,

    (real_T)(*chartInstance->c1_aacCom)[0], (real_T)chartInstance->c1_lastAacCom,

    0, 1U, (*chartInstance->c1_aacCom)[0] != chartInstance->c1_lastAacCom) != 0U,

    chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 121U, 1, ((*chartInstance->c1_aacCom)[1] ==

      ACC_READY) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(121U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 121U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastAacCom = (*chartInstance->c1_aacCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

      &chartInstance->c1_lastAacCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAacCom, 1U);

    c1_u7 = chartInstance->c1_lastAacCom;

    sf_mex_printf("%s =\\n", "lastAacCom");

    sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u7);

    chartInstance->c1_tp_DEFAULT = 0U;

    chartInstance->c1_is_ACCELERATION = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 47U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_ACCELERATION = c1_IN_ACC;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

      &chartInstance->c1_is_ACCELERATION);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

      (chartInstance->c1_is_ACCELERATION == 2));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_ACC = 1U;

    chartInstance->c1_aacCounter = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

      &chartInstance->c1_aacCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

    chartInstance->c1_aac_clutchValue = 0.0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 45, 561U, (void *)

      &chartInstance->c1_aac_clutchValue);

    _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchValue, 6U);

    chartInstance->c1_aac_clutchStep = 0.0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 46, 563U, (void *)

      &chartInstance->c1_aac_clutchStep);

    _SFD_DATA_RANGE_CHECK(chartInstance->c1_aac_clutchStep, 5U);

    chartInstance->c1_aac_dtRelease = 0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 47, 564U, (void *)

      &chartInstance->c1_aac_dtRelease);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aac_dtRelease, 7U);

    chartInstance->c1_is_ACC = c1_IN_ACTIVE;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

      &chartInstance->c1_is_ACC);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

      (chartInstance->c1_is_ACC == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

      (chartInstance->c1_is_ACC == 2));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_ACTIVE = 1U;

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 105U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACTIVE == c1_IN_START) {

    } else {

      chartInstance->c1_is_ACTIVE = c1_IN_START;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

        &chartInstance->c1_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

        (chartInstance->c1_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 19);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 2, 820U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 3, 434U, 1);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 4, 538U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 42U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_START = 1U;

      *chartInstance->c1_stateFb = (uint16_T)ACC_READY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

        chartInstance->c1_stateFb);

      _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

      chartInstance->c1_aacCounter = c1_const_AAC_WORK_RATE_ms;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

        &chartInstance->c1_aacCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_aacCounter, 4U);

      c1_u8 = chartInstance->c1_aacCounter;

      sf_mex_printf("%s =\\n", "aacCounter");

      sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u8);

      sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

      c1_Clutch_setValue(chartInstance, 100U);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 47U, chartInstance->c1_sfEvent);

    *chartInstance->c1_stateFb = (uint16_T)ACC_OFF;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_checkShift(chartInstance);

    c1_checkClutch(chartInstance);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 47U, chartInstance->c1_sfEvent);

}



static void c1_AUTOCROSS(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  int32_T c1_i45;

  int32_T c1_i46;

  int32_T c1_i47;

  int32_T c1_i48;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 179U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 179U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 179U, 0,

    (real_T)(*chartInstance->c1_modeCom)[0], (real_T)

    (*chartInstance->c1_lastModeCom)[0], 0, 1U, (*chartInstance->c1_modeCom)[0]

    != (*chartInstance->c1_lastModeCom)[0]) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 179U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U, 179U,

      1, (real_T)(*chartInstance->c1_modeCom)[1], (real_T)

      (*chartInstance->c1_lastModeCom)[1], 0, 1U, (*chartInstance->c1_modeCom)[1]

      != (*chartInstance->c1_lastModeCom)[1]) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(179U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 179U, chartInstance->c1_sfEvent);

    sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

    *chartInstance->c1_stateFb = (uint16_T)ACC_OFF;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_Clutch_setValue(chartInstance, 0U);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 145U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 137U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(137U, (int32_T)_SFD_CCP_CALL(5U, 137U, 0,

      ((*chartInstance->c1_modeCom)[1] == ENDURANCE_MODE) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 137U, chartInstance->c1_sfEvent);

      c1_exit_internal_AUTOCROSS(chartInstance);

      chartInstance->c1_tp_AUTOCROSS = 0U;

      chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

        (chartInstance->c1_is_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

        (chartInstance->c1_is_MODES == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

        (chartInstance->c1_is_MODES == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

        (chartInstance->c1_is_MODES == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

        (chartInstance->c1_is_MODES == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

        &chartInstance->c1_is_AUTOCROSS);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

      } else {

        chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

          &chartInstance->c1_is_MODES);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_MANUAL_MODES = 1U;

        c1_enter_atomic_MANUAL_MODES(chartInstance);

      }



      chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

        &chartInstance->c1_is_MANUAL_MODES);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_ENDURANCE = 1U;

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 138U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 139U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(139U, (int32_T)_SFD_CCP_CALL(5U, 139U, 0,

        ((*chartInstance->c1_modeCom)[1] == SKIDPAD_MODE) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 139U, chartInstance->c1_sfEvent);

        c1_exit_internal_AUTOCROSS(chartInstance);

        chartInstance->c1_tp_AUTOCROSS = 0U;

        chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

          &chartInstance->c1_is_AUTOCROSS);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

        } else {

          chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

            &chartInstance->c1_is_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_MANUAL_MODES = 1U;

          c1_enter_atomic_MANUAL_MODES(chartInstance);

        }



        if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

        } else {

          chartInstance->c1_is_MANUAL_MODES = c1_IN_SKIDPAD;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

            &chartInstance->c1_is_MANUAL_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 3);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_SKIDPAD = 1U;

          sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 140U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 141U,

                     chartInstance->c1_sfEvent);

        c1_e_out = (CV_TRANSITION_EVAL(141U, (int32_T)_SFD_CCP_CALL(5U, 141U, 0,

          ((*chartInstance->c1_modeCom)[1] == ACCELERATION_MODE) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 141U, chartInstance->c1_sfEvent);

          c1_exit_internal_AUTOCROSS(chartInstance);

          chartInstance->c1_tp_AUTOCROSS = 0U;

          chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

            &chartInstance->c1_is_AUTOCROSS);

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

          } else {

            chartInstance->c1_is_MODES = c1_IN_ACCELERATION;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

              &chartInstance->c1_is_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ACCELERATION = 1U;

            c1_enter_atomic_ACCELERATION(chartInstance);

          }



          c1_enter_internal_ACCELERATION(chartInstance);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 177U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 186U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 185U,

                       chartInstance->c1_sfEvent);

          c1_f_out = (CV_TRANSITION_EVAL(185U, (int32_T)_SFD_CCP_CALL(5U, 185U,

            0, ((*chartInstance->c1_modeCom)[1] == AUTOX_MODE) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_f_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 185U, chartInstance->c1_sfEvent);

            c1_exit_internal_AUTOCROSS(chartInstance);

            chartInstance->c1_tp_AUTOCROSS = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

              &chartInstance->c1_is_AUTOCROSS);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_ACCELERATION_PID;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_ACCELERATION_PID = 1U;

              chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

                &chartInstance->c1_lastAutoXCom);

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i46 = 0; c1_i46 < 2; c1_i46++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i46], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i48 = 0; c1_i48 < 2; c1_i48++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i48], 48U);

              }

            }



            c1_enter_internal_ACCELERATION_PID(chartInstance);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 178U, chartInstance->c1_sfEvent);

            c1_exit_internal_AUTOCROSS(chartInstance);

            chartInstance->c1_tp_AUTOCROSS = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

              &chartInstance->c1_is_AUTOCROSS);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_MANUAL_MODES = 1U;

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i45 = 0; c1_i45 < 2; c1_i45++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i45], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i47 = 0; c1_i47 < 2; c1_i47++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i47], 48U);

              }



              c1_checkShift(chartInstance);

              c1_checkClutch(chartInstance);

            }



            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 136U, chartInstance->c1_sfEvent);

            chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ENDURANCE = 1U;

          }

        }

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 61U, chartInstance->c1_sfEvent);

    switch (chartInstance->c1_is_AUTOCROSS) {

     case c1_b_IN_DEFAULT:

      CV_STATE_EVAL(61, 0, c1_b_IN_DEFAULT);

      c1_b_DEFAULT(chartInstance);

      break;



     case c1_IN_LAUNCH:

      CV_STATE_EVAL(61, 0, c1_IN_LAUNCH);

      c1_LAUNCH(chartInstance);

      break;



     default:

      CV_STATE_EVAL(61, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

        (chartInstance->c1_is_AUTOCROSS == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

        (chartInstance->c1_is_AUTOCROSS == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

      break;

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 61U, chartInstance->c1_sfEvent);

}



static void c1_exit_internal_AUTOCROSS(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_AUTOCROSS) {

   case c1_b_IN_DEFAULT:

    CV_STATE_EVAL(61, 1, c1_b_IN_DEFAULT);

    chartInstance->c1_b_tp_DEFAULT = 0U;

    chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_LAUNCH:

    CV_STATE_EVAL(61, 1, c1_IN_LAUNCH);

    switch (chartInstance->c1_is_LAUNCH) {

     case c1_IN_ACTIVE:

      CV_STATE_EVAL(63, 1, c1_IN_ACTIVE);

      c1_b_exit_internal_ACTIVE(chartInstance);

      chartInstance->c1_b_tp_ACTIVE = 0U;

      chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

        &chartInstance->c1_b_is_ACTIVE);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_STOPPING:

      CV_STATE_EVAL(63, 1, c1_IN_STOPPING);

      chartInstance->c1_b_tp_STOPPING = 0U;

      chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(63, 1, 0);

      chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

      break;

    }



    chartInstance->c1_tp_LAUNCH = 0U;

    chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

      &chartInstance->c1_is_LAUNCH);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 63U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(61, 1, 0);

    chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_LAUNCH(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 63U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_LAUNCH) {

   case c1_IN_ACTIVE:

    CV_STATE_EVAL(63, 0, c1_IN_ACTIVE);

    c1_b_ACTIVE(chartInstance);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 63U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_STOPPING:

    CV_STATE_EVAL(63, 0, c1_IN_STOPPING);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 155U, chartInstance->c1_sfEvent);

    chartInstance->c1_b_tp_STOPPING = 0U;

    chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_LAUNCH = 0U;

    chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

      &chartInstance->c1_is_LAUNCH);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 63U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_AUTOCROSS == c1_b_IN_DEFAULT) {

    } else {

      chartInstance->c1_is_AUTOCROSS = c1_b_IN_DEFAULT;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

        &chartInstance->c1_is_AUTOCROSS);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

        (chartInstance->c1_is_AUTOCROSS == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

        (chartInstance->c1_is_AUTOCROSS == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 18);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_DEFAULT = 1U;

      *chartInstance->c1_stateFb = (uint16_T)AUTOX_DEFAULT;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

        chartInstance->c1_stateFb);

      _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

      c1_checkShift(chartInstance);

      c1_checkClutch(chartInstance);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 71U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_AUTOCROSS != c1_IN_LAUNCH) {

    } else {

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 63U, chartInstance->c1_sfEvent);

    }

    break;



   default:

    CV_STATE_EVAL(63, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 63U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_b_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  int32_T c1_i49;

  uint16_T c1_u9;

  boolean_T c1_b_temp;

  int32_T c1_i50;

  boolean_T c1_covSaturation;

  boolean_T c1_c_temp;

  boolean_T c1_d_out;

  boolean_T c1_d_temp;

  int32_T c1_i51;

  boolean_T c1_e_out;

  real_T c1_d3;

  boolean_T c1_b_covSaturation;

  uint8_T c1_u10;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_c_covSaturation;

  int32_T c1_qY;

  int64_T c1_i52;

  boolean_T c1_d_covSaturation;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 153U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 153U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 153U, 0,

    (real_T)(*chartInstance->c1_autoXCom)[0], (real_T)

    chartInstance->c1_lastAutoXCom, 0, 1U, (*chartInstance->c1_autoXCom)[0] !=

    chartInstance->c1_lastAutoXCom) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 153U, 1, ((*chartInstance->c1_autoXCom)[1] ==

      AUTOX_DEFAULT) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(153U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 153U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

      &chartInstance->c1_lastAutoXCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

    c1_u9 = chartInstance->c1_lastAutoXCom;

    sf_mex_printf("%s =\\n", "lastAutoXCom");

    sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u9);

    c1_b_exit_internal_ACTIVE(chartInstance);

    chartInstance->c1_b_tp_ACTIVE = 0U;

    chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

      &chartInstance->c1_b_is_ACTIVE);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_LAUNCH == c1_IN_STOPPING) {

    } else {

      chartInstance->c1_is_LAUNCH = c1_IN_STOPPING;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

        &chartInstance->c1_is_LAUNCH);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

        (chartInstance->c1_is_LAUNCH == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 24);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 7);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 6);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_STOPPING = 1U;

      sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

      c1_Clutch_setValue(chartInstance, 0U);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

    switch (chartInstance->c1_b_is_ACTIVE) {

     case c1_IN_READY:

      CV_STATE_EVAL(64, 0, c1_IN_READY);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 159U,

                   chartInstance->c1_sfEvent);

      c1_c_out = (CV_TRANSITION_EVAL(159U, (int32_T)_SFD_CCP_CALL(5U, 159U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 159U, 0, (real_T)

        chartInstance->c1_autoXCounter, 1.0, 0, 3U,

        chartInstance->c1_autoXCounter <= 1) != 0U, chartInstance->c1_sfEvent))

                  != 0);

      if (c1_c_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 159U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 160U,

                     chartInstance->c1_sfEvent);

        c1_c_temp = _SFD_CCP_CALL(5U, 160U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U,

          160U, 0, (real_T)(*chartInstance->c1_autoXCom)[0], (real_T)

          chartInstance->c1_lastAutoXCom, 0, 1U, (*chartInstance->c1_autoXCom)[0]

          != chartInstance->c1_lastAutoXCom) != 0U, chartInstance->c1_sfEvent);

        if (c1_c_temp) {

          c1_c_temp = _SFD_CCP_CALL(5U, 160U, 1, ((*chartInstance->c1_autoXCom)

            [1] == AUTOX_GO) != 0U, chartInstance->c1_sfEvent);

        }



        c1_d_temp = c1_c_temp;

        if (c1_d_temp) {

          c1_i51 = c1_getAutoXParam(chartInstance,

            autoX_params_AUTOX_TPS_START_LIMIT);

          c1_d_temp = _SFD_CCP_CALL(5U, 160U, 2, (boolean_T)CV_RELATIONAL_EVAL

            (5U, 160U, 1, (real_T)*chartInstance->c1_currTps, (real_T)c1_i51, 0,

             5U, *chartInstance->c1_currTps >= c1_i51) != 0U,

            chartInstance->c1_sfEvent);

        }



        c1_e_out = (CV_TRANSITION_EVAL(160U, (int32_T)c1_d_temp) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 160U, chartInstance->c1_sfEvent);

          chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

            &chartInstance->c1_lastAutoXCom);

          _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

          chartInstance->c1_b_tp_READY = 0U;

          chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 5));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_b_is_ACTIVE == c1_IN_START_RELEASE) {

          } else {

            chartInstance->c1_b_is_ACTIVE = c1_IN_START_RELEASE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

              &chartInstance->c1_b_is_ACTIVE);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 21);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 4);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 3);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 3);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 69U, chartInstance->c1_sfEvent);

            chartInstance->c1_b_tp_START_RELEASE = 1U;

            *chartInstance->c1_stateFb = (uint16_T)AUTOX_GO;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

              chartInstance->c1_stateFb);

            _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

            chartInstance->c1_autoX_clutchValue = (real_T)c1_getAutoXParam

              (chartInstance, autoX_params_AUTOX_RAMP_START);

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 64, 959U, (void *)

              &chartInstance->c1_autoX_clutchValue);

            _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchValue, 10U);

            c1_d3 = chartInstance->c1_autoX_clutchValue;

            c1_b_covSaturation = false;

            if (c1_d3 < 256.0) {

              if (c1_d3 >= 0.0) {

                c1_u10 = (uint8_T)c1_d3;

              } else {

                c1_b_covSaturation = true;

                c1_u10 = 0U;

                _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 121U, 5U);

              }

            } else if (c1_d3 >= 256.0) {

              c1_b_covSaturation = true;

              c1_u10 = MAX_uint8_T;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 121U, 5U);

            } else {

              c1_u10 = 0U;

            }



            CV_SATURATION_EVAL(4, 69, 0, 0, c1_b_covSaturation);

            c1_Clutch_setValue(chartInstance, c1_u10);

            chartInstance->c1_autoX_dtRelease = c1_div_nzp_s32(chartInstance,

              c1_getAutoXParam(chartInstance, autoX_params_AUTOX_RAMP_TIME),

              (int32_T)c1_const_AUTOX_WORK_RATE_ms, 1001U, 198, 1);

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 66, 961U, (void *)

              &chartInstance->c1_autoX_dtRelease);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoX_dtRelease, 11U);

            c1_q0 = c1_getAutoXParam(chartInstance,

              autoX_params_AUTOX_RAMP_START);

            c1_q1 = c1_getAutoXParam(chartInstance, autoX_params_AUTOX_RAMP_END);

            c1_c_covSaturation = false;

            if ((c1_q0 >= 0) && (c1_q1 < c1_q0 - MAX_int32_T)) {

              c1_c_covSaturation = true;

              c1_qY = MAX_int32_T;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 287U, 1U);

            } else if ((c1_q0 < 0) && (c1_q1 > c1_q0 - MIN_int32_T)) {

              c1_c_covSaturation = true;

              c1_qY = MIN_int32_T;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 287U, 1U);

            } else {

              c1_qY = c1_q0 - c1_q1;

            }



            CV_SATURATION_EVAL(4, 69, 1, 0, c1_c_covSaturation);

            c1_i52 = (int64_T)c1_qY * (int64_T)c1_const_AUTOX_WORK_RATE_ms;

            c1_d_covSaturation = false;

            if (c1_i52 > 2147483647LL) {

              c1_d_covSaturation = true;

              c1_i52 = 2147483647LL;

              _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 320U, 1U);

            } else {

              if (c1_i52 < -2147483648LL) {

                c1_d_covSaturation = true;

                c1_i52 = -2147483648LL;

                _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 320U, 1U);

              }

            }



            CV_SATURATION_EVAL(4, 69, 2, 0, c1_d_covSaturation);

            chartInstance->c1_autoX_clutchStep = (real_T)(int32_T)c1_i52 /

              (real_T)c1_getAutoXParam(chartInstance,

              autoX_params_AUTOX_RAMP_TIME);

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 65, 960U, (void *)

              &chartInstance->c1_autoX_clutchStep);

            _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchStep, 9U);

            chartInstance->c1_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

              &chartInstance->c1_autoXCounter);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

          }

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 157U, chartInstance->c1_sfEvent);

          chartInstance->c1_b_tp_READY = 0U;

          chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

            (chartInstance->c1_b_is_ACTIVE == 5));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_b_is_ACTIVE == c1_IN_READY) {

          } else {

            chartInstance->c1_b_is_ACTIVE = c1_IN_READY;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

              &chartInstance->c1_b_is_ACTIVE);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

              (chartInstance->c1_b_is_ACTIVE == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 20);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 3);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 2);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

            chartInstance->c1_b_tp_READY = 1U;

            c1_b_enter_atomic_READY(chartInstance);

          }

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 65U,

                     chartInstance->c1_sfEvent);

        c1_i50 = c1__s32_minus__(chartInstance, (int32_T)

          chartInstance->c1_autoXCounter, 1, 999U, 139, 1);

        c1_covSaturation = false;

        if (c1_i50 < 0) {

          c1_covSaturation = true;

          c1_i50 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 999U, 139U, 1U);

        } else {

          if (c1_i50 > 65535) {

            c1_i50 = 65535;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 999U, 139U, 1U);

          }



          CV_SATURATION_EVAL(4, 65, 0, 0, c1_covSaturation);

        }



        chartInstance->c1_autoXCounter = (uint16_T)c1_i50;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

          &chartInstance->c1_autoXCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

        c1_checkShift(chartInstance);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 65U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_RELEASING:

      CV_STATE_EVAL(64, 0, c1_IN_RELEASING);

      c1_b_RELEASING(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_RUNNING:

      CV_STATE_EVAL(64, 0, c1_IN_RUNNING);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 154U,

                   chartInstance->c1_sfEvent);

      c1_i49 = (*chartInstance->c1_autoX_parameters)[(uint8_T)

        sf_array_bounds_check(sfGlobalDebugInstanceStruct, chartInstance->S,

        977U, 13, 16, 32U, (int32_T)c1__u8_s32_(chartInstance, (int32_T)

        autoX_params_AUTOX_END_GEAR, 977U, 13, 16), 0, 15)];

      c1_b_temp = _SFD_CCP_CALL(5U, 154U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U,

        154U, 0, (real_T)*chartInstance->c1_currGear, (real_T)c1_i49, 0, 5U,

        *chartInstance->c1_currGear >= c1_i49) != 0U, chartInstance->c1_sfEvent);

      if (c1_b_temp) {

        c1_b_temp = _SFD_CCP_CALL(5U, 154U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

          154U, 1, (real_T)*chartInstance->c1_currGear, 8.0, 0, 1U,

          *chartInstance->c1_currGear != 8) != 0U, chartInstance->c1_sfEvent);

      }



      c1_d_out = (CV_TRANSITION_EVAL(154U, (int32_T)c1_b_temp) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 154U, chartInstance->c1_sfEvent);

        chartInstance->c1_b_tp_RUNNING = 0U;

        chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 67U, chartInstance->c1_sfEvent);

        chartInstance->c1_b_tp_ACTIVE = 0U;

        chartInstance->c1_is_LAUNCH = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

          (chartInstance->c1_is_LAUNCH == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

          (chartInstance->c1_is_LAUNCH == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

          &chartInstance->c1_b_is_ACTIVE);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_LAUNCH == c1_IN_STOPPING) {

        } else {

          chartInstance->c1_is_LAUNCH = c1_IN_STOPPING;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

            &chartInstance->c1_is_LAUNCH);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

            (chartInstance->c1_is_LAUNCH == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

            (chartInstance->c1_is_LAUNCH == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 24);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 7);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 6);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

          chartInstance->c1_b_tp_STOPPING = 1U;

          sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

          c1_Clutch_setValue(chartInstance, 0U);

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 67U,

                     chartInstance->c1_sfEvent);

        c1_autoXCheckShift(chartInstance);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 67U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_LAUNCH != c1_IN_ACTIVE) {

      } else {

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

      }

      break;



     case c1_IN_START:

      CV_STATE_EVAL(64, 0, c1_IN_START);

      c1_b_START(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_START_RELEASE:

      CV_STATE_EVAL(64, 0, c1_IN_START_RELEASE);

      c1_b_START_RELEASE(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(64, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 64U, chartInstance->c1_sfEvent);

      break;

    }

  }

}



static void c1_b_exit_internal_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_b_is_ACTIVE) {

   case c1_IN_READY:

    CV_STATE_EVAL(64, 1, c1_IN_READY);

    chartInstance->c1_b_tp_READY = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_RELEASING:

    CV_STATE_EVAL(64, 1, c1_IN_RELEASING);

    chartInstance->c1_b_tp_RELEASING = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_RUNNING:

    CV_STATE_EVAL(64, 1, c1_IN_RUNNING);

    chartInstance->c1_b_tp_RUNNING = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 67U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_START:

    CV_STATE_EVAL(64, 1, c1_IN_START);

    chartInstance->c1_b_tp_START = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 68U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_START_RELEASE:

    CV_STATE_EVAL(64, 1, c1_IN_START_RELEASE);

    chartInstance->c1_b_tp_START_RELEASE = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 69U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(64, 1, 0);

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_b_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i53;

  boolean_T c1_covSaturation;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 158U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(158U, (int32_T)_SFD_CCP_CALL(5U, 158U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 158U, 0, (real_T)

    chartInstance->c1_autoXCounter, 1.0, 0, 3U, chartInstance->c1_autoXCounter <=

    1) != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 158U, chartInstance->c1_sfEvent);

    chartInstance->c1_b_tp_START = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 68U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_b_is_ACTIVE == c1_IN_READY) {

    } else {

      chartInstance->c1_b_is_ACTIVE = c1_IN_READY;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

        &chartInstance->c1_b_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 20);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 3);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 2);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_READY = 1U;

      c1_b_enter_atomic_READY(chartInstance);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 68U, chartInstance->c1_sfEvent);

    c1_i53 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_autoXCounter, 1, 998U, 165, 1);

    c1_covSaturation = false;

    if (c1_i53 < 0) {

      c1_covSaturation = true;

      c1_i53 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 998U, 165U, 1U);

    } else {

      if (c1_i53 > 65535) {

        c1_i53 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 998U, 165U, 1U);

      }



      CV_SATURATION_EVAL(4, 68, 0, 0, c1_covSaturation);

    }



    chartInstance->c1_autoXCounter = (uint16_T)c1_i53;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

      &chartInstance->c1_autoXCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 68U, chartInstance->c1_sfEvent);

}



static void c1_b_enter_atomic_READY(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  uint16_T c1_u11;

  *chartInstance->c1_stateFb = (uint16_T)AUTOX_READY;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

    chartInstance->c1_stateFb);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

  chartInstance->c1_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

    &chartInstance->c1_autoXCounter);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

  c1_u11 = chartInstance->c1_autoXCounter;

  sf_mex_printf("%s =\\n", "autoXCounter");

  sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u11);

  c1_Clutch_setValue(chartInstance, 100U);

  c1_checkShift(chartInstance);

}



static void c1_b_START_RELEASE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i54;

  boolean_T c1_covSaturation;

  real_T c1_d4;

  boolean_T c1_b_covSaturation;

  uint8_T c1_u12;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_c_covSaturation;

  int32_T c1_qY;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 161U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(161U, (int32_T)_SFD_CCP_CALL(5U, 161U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 161U, 0, (real_T)

    chartInstance->c1_autoXCounter, 1.0, 0, 3U, chartInstance->c1_autoXCounter <=

    1) != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 161U, chartInstance->c1_sfEvent);

    chartInstance->c1_b_tp_START_RELEASE = 0U;

    chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

      (chartInstance->c1_b_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 69U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_b_is_ACTIVE == c1_IN_RELEASING) {

    } else {

      chartInstance->c1_b_is_ACTIVE = c1_IN_RELEASING;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

        &chartInstance->c1_b_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 22);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 5);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 4);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 4);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_RELEASING = 1U;

      chartInstance->c1_autoX_clutchValue -= chartInstance->c1_autoX_clutchStep;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 64, 959U, (void *)

        &chartInstance->c1_autoX_clutchValue);

      _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchValue, 10U);

      c1_d4 = chartInstance->c1_autoX_clutchValue;

      c1_b_covSaturation = false;

      if (c1_d4 < 256.0) {

        if (c1_d4 >= 0.0) {

          c1_u12 = (uint8_T)c1_d4;

        } else {

          c1_b_covSaturation = true;

          c1_u12 = 0U;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 93U, 5U);

        }

      } else if (c1_d4 >= 256.0) {

        c1_b_covSaturation = true;

        c1_u12 = MAX_uint8_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 93U, 5U);

      } else {

        c1_u12 = 0U;

      }



      CV_SATURATION_EVAL(4, 66, 2, 0, c1_b_covSaturation);

      c1_Clutch_setValue(chartInstance, c1_u12);

      c1_q0 = chartInstance->c1_autoX_dtRelease;

      c1_q1 = 1;

      c1_c_covSaturation = false;

      if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

        c1_c_covSaturation = true;

        c1_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 155U, 1U);

      } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

        c1_c_covSaturation = true;

        c1_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 155U, 1U);

      } else {

        c1_qY = c1_q0 - c1_q1;

      }



      CV_SATURATION_EVAL(4, 66, 0, 0, c1_c_covSaturation);

      chartInstance->c1_autoX_dtRelease = c1_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 66, 961U, (void *)

        &chartInstance->c1_autoX_dtRelease);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoX_dtRelease, 11U);

      chartInstance->c1_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

        &chartInstance->c1_autoXCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 69U, chartInstance->c1_sfEvent);

    c1_i54 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_autoXCounter, 1, 1001U, 464, 1);

    c1_covSaturation = false;

    if (c1_i54 < 0) {

      c1_covSaturation = true;

      c1_i54 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 464U, 1U);

    } else {

      if (c1_i54 > 65535) {

        c1_i54 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1001U, 464U, 1U);

      }



      CV_SATURATION_EVAL(4, 69, 3, 0, c1_covSaturation);

    }



    chartInstance->c1_autoXCounter = (uint16_T)c1_i54;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

      &chartInstance->c1_autoXCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 69U, chartInstance->c1_sfEvent);

}



static void c1_b_RELEASING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i55;

  boolean_T c1_covSaturation;

  boolean_T c1_temp;

  int32_T c1_i56;

  boolean_T c1_c_out;

  real_T c1_d5;

  boolean_T c1_b_covSaturation;

  uint16_T c1_u13;

  uint8_T c1_u14;

  uint16_T c1_u15;

  boolean_T c1_c_covSaturation;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_d_covSaturation;

  int32_T c1_qY;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 164U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(164U, (int32_T)_SFD_CCP_CALL(5U, 164U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 164U, 0, (real_T)

    chartInstance->c1_autoXCounter, 1.0, 0, 3U, chartInstance->c1_autoXCounter <=

    1) != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 164U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 162U,

                 chartInstance->c1_sfEvent);

    c1_temp = _SFD_CCP_CALL(5U, 162U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 162U,

      0, (real_T)chartInstance->c1_autoX_dtRelease, 0.0, 0, 3U,

      chartInstance->c1_autoX_dtRelease <= 0) != 0U, chartInstance->c1_sfEvent);

    if (!c1_temp) {

      c1_i56 = c1_getAutoXParam(chartInstance, autoX_params_AUTOX_RAMP_END);

      c1_temp = _SFD_CCP_CALL(5U, 162U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

        162U, 1, (real_T)*chartInstance->c1_clutchCurrVal, (real_T)c1_i56, 0, 3U,

        *chartInstance->c1_clutchCurrVal <= c1_i56) != 0U,

        chartInstance->c1_sfEvent);

    }



    c1_c_out = (CV_TRANSITION_EVAL(162U, (int32_T)c1_temp) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 162U, chartInstance->c1_sfEvent);

      c1_Clutch_setValue(chartInstance, 0U);

      sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

      chartInstance->c1_b_tp_RELEASING = 0U;

      chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_b_is_ACTIVE == c1_IN_RUNNING) {

      } else {

        chartInstance->c1_b_is_ACTIVE = c1_IN_RUNNING;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

          &chartInstance->c1_b_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 23);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 6);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 5);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 5);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 67U, chartInstance->c1_sfEvent);

        chartInstance->c1_b_tp_RUNNING = 1U;

        chartInstance->c1_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

          &chartInstance->c1_autoXCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

        c1_u13 = chartInstance->c1_autoXCounter;

        sf_mex_printf("%s =\\n", "autoXCounter");

        sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11,

                          c1_u13);

        c1_u15 = *chartInstance->c1_currGear;

        c1_c_covSaturation = false;

        if (c1_u15 > 255) {

          c1_c_covSaturation = true;

          c1_u15 = 255U;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1002U, 64U, 8U);

        }



        CV_SATURATION_EVAL(4, 67, 0, 0, c1_c_covSaturation);

        chartInstance->c1_lastShift = (uint8_T)c1_u15;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

          &chartInstance->c1_lastShift);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

        c1_autoXCheckShift(chartInstance);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 163U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_RELEASING = 0U;

      chartInstance->c1_b_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_b_is_ACTIVE == c1_IN_RELEASING) {

      } else {

        chartInstance->c1_b_is_ACTIVE = c1_IN_RELEASING;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

          &chartInstance->c1_b_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

          (chartInstance->c1_b_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 22);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 5);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 4);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 4);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

        chartInstance->c1_b_tp_RELEASING = 1U;

        chartInstance->c1_autoX_clutchValue -=

          chartInstance->c1_autoX_clutchStep;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 64, 959U, (void *)

          &chartInstance->c1_autoX_clutchValue);

        _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchValue, 10U);

        c1_d5 = chartInstance->c1_autoX_clutchValue;

        c1_b_covSaturation = false;

        if (c1_d5 < 256.0) {

          if (c1_d5 >= 0.0) {

            c1_u14 = (uint8_T)c1_d5;

          } else {

            c1_b_covSaturation = true;

            c1_u14 = 0U;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 93U, 5U);

          }

        } else if (c1_d5 >= 256.0) {

          c1_b_covSaturation = true;

          c1_u14 = MAX_uint8_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 93U, 5U);

        } else {

          c1_u14 = 0U;

        }



        CV_SATURATION_EVAL(4, 66, 2, 0, c1_b_covSaturation);

        c1_Clutch_setValue(chartInstance, c1_u14);

        c1_q0 = chartInstance->c1_autoX_dtRelease;

        c1_q1 = 1;

        c1_d_covSaturation = false;

        if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

          c1_d_covSaturation = true;

          c1_qY = MAX_int32_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 155U, 1U);

        } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

          c1_d_covSaturation = true;

          c1_qY = MIN_int32_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 155U, 1U);

        } else {

          c1_qY = c1_q0 - c1_q1;

        }



        CV_SATURATION_EVAL(4, 66, 0, 0, c1_d_covSaturation);

        chartInstance->c1_autoX_dtRelease = c1_qY;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 66, 961U, (void *)

          &chartInstance->c1_autoX_dtRelease);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoX_dtRelease, 11U);

        chartInstance->c1_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

          &chartInstance->c1_autoXCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 66U, chartInstance->c1_sfEvent);

    c1_i55 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_autoXCounter, 1, 1025U, 233, 1);

    c1_covSaturation = false;

    if (c1_i55 < 0) {

      c1_covSaturation = true;

      c1_i55 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 233U, 1U);

    } else {

      if (c1_i55 > 65535) {

        c1_i55 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1025U, 233U, 1U);

      }



      CV_SATURATION_EVAL(4, 66, 1, 0, c1_covSaturation);

    }



    chartInstance->c1_autoXCounter = (uint16_T)c1_i55;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

      &chartInstance->c1_autoXCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 66U, chartInstance->c1_sfEvent);

}



static void c1_b_DEFAULT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  uint16_T c1_u16;

  uint16_T c1_u17;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 152U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 152U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 152U, 0,

    (real_T)(*chartInstance->c1_autoXCom)[0], (real_T)

    chartInstance->c1_lastAutoXCom, 0, 1U, (*chartInstance->c1_autoXCom)[0] !=

    chartInstance->c1_lastAutoXCom) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 152U, 1, ((*chartInstance->c1_autoXCom)[1] ==

      AUTOX_READY) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(152U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 152U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

      &chartInstance->c1_lastAutoXCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

    c1_u16 = chartInstance->c1_lastAutoXCom;

    sf_mex_printf("%s =\\n", "lastAutoXCom");

    sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u16);

    chartInstance->c1_b_tp_DEFAULT = 0U;

    chartInstance->c1_is_AUTOCROSS = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_AUTOCROSS = c1_IN_LAUNCH;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

      &chartInstance->c1_is_AUTOCROSS);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

      (chartInstance->c1_is_AUTOCROSS == 2));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 63U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_LAUNCH = 1U;

    chartInstance->c1_autoXCounter = 0U;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

      &chartInstance->c1_autoXCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

    chartInstance->c1_autoX_clutchValue = 0.0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 64, 959U, (void *)

      &chartInstance->c1_autoX_clutchValue);

    _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchValue, 10U);

    chartInstance->c1_autoX_clutchStep = 0.0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 65, 960U, (void *)

      &chartInstance->c1_autoX_clutchStep);

    _SFD_DATA_RANGE_CHECK(chartInstance->c1_autoX_clutchStep, 9U);

    chartInstance->c1_autoX_dtRelease = 0;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 66, 961U, (void *)

      &chartInstance->c1_autoX_dtRelease);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoX_dtRelease, 11U);

    chartInstance->c1_is_LAUNCH = c1_IN_ACTIVE;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

      &chartInstance->c1_is_LAUNCH);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

      (chartInstance->c1_is_LAUNCH == 2));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

    chartInstance->c1_b_tp_ACTIVE = 1U;

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 156U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_b_is_ACTIVE == c1_IN_START) {

    } else {

      chartInstance->c1_b_is_ACTIVE = c1_IN_START;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

        &chartInstance->c1_b_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

        (chartInstance->c1_b_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 19);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 22, 951U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 24, 974U, 1);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 25, 985U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 68U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_START = 1U;

      *chartInstance->c1_stateFb = (uint16_T)AUTOX_READY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

        chartInstance->c1_stateFb);

      _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

      chartInstance->c1_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

        &chartInstance->c1_autoXCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_autoXCounter, 8U);

      c1_u17 = chartInstance->c1_autoXCounter;

      sf_mex_printf("%s =\\n", "autoXCounter");

      sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u17);

      sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

      c1_Clutch_setValue(chartInstance, 100U);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 62U, chartInstance->c1_sfEvent);

    *chartInstance->c1_stateFb = (uint16_T)AUTOX_DEFAULT;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_checkShift(chartInstance);

    c1_checkClutch(chartInstance);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 62U, chartInstance->c1_sfEvent);

}



static void c1_enter_internal_ACCELERATION_PID

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 184U, chartInstance->c1_sfEvent);

  if (chartInstance->c1_is_ACCELERATION_PID == c1_b_IN_DEFAULT) {

  } else {

    chartInstance->c1_is_ACCELERATION_PID = c1_b_IN_DEFAULT;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

      &chartInstance->c1_is_ACCELERATION_PID);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 18);

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 1);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

    chartInstance->c1_c_tp_DEFAULT = 1U;

    *chartInstance->c1_stateFb = (uint16_T)AUTOX_DEFAULT;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_checkShift(chartInstance);

    c1_checkClutch(chartInstance);

  }

}



static void c1_ACCELERATION_PID(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  int32_T c1_i57;

  int32_T c1_i58;

  int32_T c1_i59;

  int32_T c1_i60;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 187U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 187U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 187U, 0,

    (real_T)(*chartInstance->c1_modeCom)[0], (real_T)

    (*chartInstance->c1_lastModeCom)[0], 0, 1U, (*chartInstance->c1_modeCom)[0]

    != (*chartInstance->c1_lastModeCom)[0]) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 187U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U, 187U,

      1, (real_T)(*chartInstance->c1_modeCom)[1], (real_T)

      (*chartInstance->c1_lastModeCom)[1], 0, 1U, (*chartInstance->c1_modeCom)[1]

      != (*chartInstance->c1_lastModeCom)[1]) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(187U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 187U, chartInstance->c1_sfEvent);

    sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

    *chartInstance->c1_stateFb = (uint16_T)ACC_OFF;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_Clutch_setValue(chartInstance, 0U);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 145U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 137U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(137U, (int32_T)_SFD_CCP_CALL(5U, 137U, 0,

      ((*chartInstance->c1_modeCom)[1] == ENDURANCE_MODE) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 137U, chartInstance->c1_sfEvent);

      c1_exit_internal_ACCELERATION_PID(chartInstance);

      chartInstance->c1_tp_ACCELERATION_PID = 0U;

      chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

        (chartInstance->c1_is_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

        (chartInstance->c1_is_MODES == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

        (chartInstance->c1_is_MODES == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

        (chartInstance->c1_is_MODES == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

        (chartInstance->c1_is_MODES == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

        &chartInstance->c1_is_ACCELERATION_PID);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

      } else {

        chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

          &chartInstance->c1_is_MODES);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_MANUAL_MODES = 1U;

        c1_enter_atomic_MANUAL_MODES(chartInstance);

      }



      chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

        &chartInstance->c1_is_MANUAL_MODES);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

        (chartInstance->c1_is_MANUAL_MODES == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_ENDURANCE = 1U;

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 138U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 139U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(139U, (int32_T)_SFD_CCP_CALL(5U, 139U, 0,

        ((*chartInstance->c1_modeCom)[1] == SKIDPAD_MODE) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 139U, chartInstance->c1_sfEvent);

        c1_exit_internal_ACCELERATION_PID(chartInstance);

        chartInstance->c1_tp_ACCELERATION_PID = 0U;

        chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

          (chartInstance->c1_is_MODES == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

          (chartInstance->c1_is_MODES == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

          (chartInstance->c1_is_MODES == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

          (chartInstance->c1_is_MODES == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

          (chartInstance->c1_is_MODES == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

          &chartInstance->c1_is_ACCELERATION_PID);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

        } else {

          chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

            &chartInstance->c1_is_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_MANUAL_MODES = 1U;

          c1_enter_atomic_MANUAL_MODES(chartInstance);

        }



        if (chartInstance->c1_is_MANUAL_MODES == c1_IN_SKIDPAD) {

        } else {

          chartInstance->c1_is_MANUAL_MODES = c1_IN_SKIDPAD;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

            &chartInstance->c1_is_MANUAL_MODES);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

            (chartInstance->c1_is_MANUAL_MODES == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 3);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_SKIDPAD = 1U;

          sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 140U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 141U,

                     chartInstance->c1_sfEvent);

        c1_e_out = (CV_TRANSITION_EVAL(141U, (int32_T)_SFD_CCP_CALL(5U, 141U, 0,

          ((*chartInstance->c1_modeCom)[1] == ACCELERATION_MODE) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 141U, chartInstance->c1_sfEvent);

          c1_exit_internal_ACCELERATION_PID(chartInstance);

          chartInstance->c1_tp_ACCELERATION_PID = 0U;

          chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

            (chartInstance->c1_is_MODES == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

            (chartInstance->c1_is_MODES == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

            (chartInstance->c1_is_MODES == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

            (chartInstance->c1_is_MODES == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

            (chartInstance->c1_is_MODES == 5));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

            &chartInstance->c1_is_ACCELERATION_PID);

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION) {

          } else {

            chartInstance->c1_is_MODES = c1_IN_ACCELERATION;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

              &chartInstance->c1_is_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ACCELERATION = 1U;

            c1_enter_atomic_ACCELERATION(chartInstance);

          }



          c1_enter_internal_ACCELERATION(chartInstance);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 177U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 186U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 185U,

                       chartInstance->c1_sfEvent);

          c1_f_out = (CV_TRANSITION_EVAL(185U, (int32_T)_SFD_CCP_CALL(5U, 185U,

            0, ((*chartInstance->c1_modeCom)[1] == AUTOX_MODE) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_f_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 185U, chartInstance->c1_sfEvent);

            c1_exit_internal_ACCELERATION_PID(chartInstance);

            chartInstance->c1_tp_ACCELERATION_PID = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

              &chartInstance->c1_is_ACCELERATION_PID);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_ACCELERATION_PID) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_ACCELERATION_PID;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_ACCELERATION_PID = 1U;

              chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

                &chartInstance->c1_lastAutoXCom);

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i58 = 0; c1_i58 < 2; c1_i58++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i58], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i60 = 0; c1_i60 < 2; c1_i60++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i60], 48U);

              }

            }



            c1_enter_internal_ACCELERATION_PID(chartInstance);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 178U, chartInstance->c1_sfEvent);

            c1_exit_internal_ACCELERATION_PID(chartInstance);

            chartInstance->c1_tp_ACCELERATION_PID = 0U;

            chartInstance->c1_is_MODES = c1_IN_NO_ACTIVE_CHILD;

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

              (chartInstance->c1_is_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

              (chartInstance->c1_is_MODES == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

              (chartInstance->c1_is_MODES == 3));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

              (chartInstance->c1_is_MODES == 4));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

              (chartInstance->c1_is_MODES == 5));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 0);

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

              &chartInstance->c1_is_ACCELERATION_PID);

            _SFD_CS_CALL(STATE_INACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_MODES == c1_IN_MANUAL_MODES) {

            } else {

              chartInstance->c1_is_MODES = c1_IN_MANUAL_MODES;

              c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

                &chartInstance->c1_is_MODES);

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

                (chartInstance->c1_is_MODES == 1));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

                (chartInstance->c1_is_MODES == 2));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

                (chartInstance->c1_is_MODES == 3));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

                (chartInstance->c1_is_MODES == 4));

              c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

                (chartInstance->c1_is_MODES == 5));

              _SFD_CS_CALL(STATE_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

              chartInstance->c1_tp_MANUAL_MODES = 1U;

              (*chartInstance->c1_lastModeCom)[0] = (*chartInstance->c1_modeCom)

                [0];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i57 = 0; c1_i57 < 2; c1_i57++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i57], 48U);

              }



              (*chartInstance->c1_lastModeCom)[1] = (*chartInstance->c1_modeCom)

                [1];

              c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

                chartInstance->c1_lastModeCom);

              for (c1_i59 = 0; c1_i59 < 2; c1_i59++) {

                _SFD_DATA_RANGE_CHECK((real_T)(*chartInstance->c1_lastModeCom)

                                      [c1_i59], 48U);

              }



              c1_checkShift(chartInstance);

              c1_checkClutch(chartInstance);

            }



            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 136U, chartInstance->c1_sfEvent);

            chartInstance->c1_is_MANUAL_MODES = c1_IN_ENDURANCE;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

              &chartInstance->c1_is_MANUAL_MODES);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

              (chartInstance->c1_is_MANUAL_MODES == 2));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 2);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 33, 727U, 1);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ENDURANCE = 1U;

          }

        }

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 48U, chartInstance->c1_sfEvent);

    switch (chartInstance->c1_is_ACCELERATION_PID) {

     case c1_b_IN_DEFAULT:

      CV_STATE_EVAL(48, 0, c1_b_IN_DEFAULT);

      c1_c_DEFAULT(chartInstance);

      break;



     case c1_IN_LAUNCH0:

      CV_STATE_EVAL(48, 0, c1_IN_LAUNCH0);

      c1_LAUNCH0(chartInstance);

      break;



     default:

      CV_STATE_EVAL(48, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

      break;

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 48U, chartInstance->c1_sfEvent);

}



static void c1_exit_internal_ACCELERATION_PID

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  switch (chartInstance->c1_is_ACCELERATION_PID) {

   case c1_b_IN_DEFAULT:

    CV_STATE_EVAL(48, 1, c1_b_IN_DEFAULT);

    chartInstance->c1_c_tp_DEFAULT = 0U;

    chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_LAUNCH0:

    CV_STATE_EVAL(48, 1, c1_IN_LAUNCH0);

    switch (chartInstance->c1_is_LAUNCH0) {

     case c1_IN_ACTIVE:

      CV_STATE_EVAL(50, 1, c1_IN_ACTIVE);

      c1_c_exit_internal_ACTIVE(chartInstance);

      if (chartInstance->c1_is_LAUNCH0 != c1_IN_ACTIVE) {

      } else {

        chartInstance->c1_c_tp_ACTIVE = 0U;

        _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG, 51U,

                     chartInstance->c1_sfEvent);

        sf_call_output_fcn_disable(chartInstance->S, 16, "ramp", 0);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

        chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

          (chartInstance->c1_is_LAUNCH0 == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

          (chartInstance->c1_is_LAUNCH0 == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 0);

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

          &chartInstance->c1_c_is_ACTIVE);

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

      }

      break;



     case c1_IN_STOPPING:

      CV_STATE_EVAL(50, 1, c1_IN_STOPPING);

      chartInstance->c1_c_tp_STOPPING = 0U;

      chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(50, 1, 0);

      chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

      break;

    }



    chartInstance->c1_tp_LAUNCH0 = 0U;

    chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

      &chartInstance->c1_is_LAUNCH0);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 50U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(48, 1, 0);

    chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_LAUNCH0(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 50U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_LAUNCH0) {

   case c1_IN_ACTIVE:

    CV_STATE_EVAL(50, 0, c1_IN_ACTIVE);

    c1_c_ACTIVE(chartInstance);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 50U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_STOPPING:

    CV_STATE_EVAL(50, 0, c1_IN_STOPPING);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 213U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 202U, chartInstance->c1_sfEvent);

    chartInstance->c1_c_tp_STOPPING = 0U;

    chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

      (chartInstance->c1_is_LAUNCH0 == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

      (chartInstance->c1_is_LAUNCH0 == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_LAUNCH0 = 0U;

    chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

      (chartInstance->c1_is_ACCELERATION_PID == 2));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

      &chartInstance->c1_is_LAUNCH0);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 50U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACCELERATION_PID == c1_b_IN_DEFAULT) {

    } else {

      chartInstance->c1_is_ACCELERATION_PID = c1_b_IN_DEFAULT;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

        &chartInstance->c1_is_ACCELERATION_PID);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 18);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

      chartInstance->c1_c_tp_DEFAULT = 1U;

      *chartInstance->c1_stateFb = (uint16_T)AUTOX_DEFAULT;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

        chartInstance->c1_stateFb);

      _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

      c1_checkShift(chartInstance);

      c1_checkClutch(chartInstance);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 59U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_ACCELERATION_PID != c1_IN_LAUNCH0) {

    } else {

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 50U, chartInstance->c1_sfEvent);

    }

    break;



   default:

    CV_STATE_EVAL(50, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

      (chartInstance->c1_is_LAUNCH0 == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

      (chartInstance->c1_is_LAUNCH0 == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 50U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_c_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_b_temp;

  uint16_T c1_u18;

  boolean_T c1_d_out;

  real_T c1_c_clutchCurrVal;

  boolean_T c1_e_out;

  real_T c1_d6;

  boolean_T c1_covSaturation;

  uint8_T c1_u19;

  uint16_T c1_u20;

  uint16_T c1_u21;

  boolean_T c1_b_covSaturation;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 211U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 211U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 211U, 0,

    (real_T)(*chartInstance->c1_autoXCom)[0], (real_T)

    chartInstance->c1_lastAutoXCom, 0, 1U, (*chartInstance->c1_autoXCom)[0] !=

    chartInstance->c1_lastAutoXCom) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 211U, 1, ((*chartInstance->c1_autoXCom)[1] ==

      AUTOX_DEFAULT) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(211U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 211U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

      &chartInstance->c1_lastAutoXCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

    c1_u18 = chartInstance->c1_lastAutoXCom;

    sf_mex_printf("%s =\\n", "lastAutoXCom");

    sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u18);

    c1_c_exit_internal_ACTIVE(chartInstance);

    if (chartInstance->c1_is_LAUNCH0 != c1_IN_ACTIVE) {

    } else {

      chartInstance->c1_c_tp_ACTIVE = 0U;

      _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      sf_call_output_fcn_disable(chartInstance->S, 16, "ramp", 0);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

        &chartInstance->c1_c_is_ACTIVE);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

    }



    if (chartInstance->c1_is_LAUNCH0 == c1_IN_STOPPING) {

    } else {

      chartInstance->c1_is_LAUNCH0 = c1_IN_STOPPING;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

        &chartInstance->c1_is_LAUNCH0);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

        (chartInstance->c1_is_LAUNCH0 == 2));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 24);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 7);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 6);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

      chartInstance->c1_c_tp_STOPPING = 1U;

      sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

      c1_Clutch_setValue(chartInstance, 0U);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

    switch (chartInstance->c1_c_is_ACTIVE) {

     case c1_IN_READY:

      CV_STATE_EVAL(51, 0, c1_IN_READY);

      c1_READY(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_RELEASE:

      CV_STATE_EVAL(51, 0, c1_IN_RELEASE);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 219U,

                   chartInstance->c1_sfEvent);

      c1_c_out = (CV_TRANSITION_EVAL(219U, (int32_T)_SFD_CCP_CALL(5U, 219U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 219U, 0, (real_T)

        *chartInstance->c1_clutchCurrVal, 0.0, 0, 0U,

        *chartInstance->c1_clutchCurrVal == 0) != 0U, chartInstance->c1_sfEvent))

                  != 0);

      if (c1_c_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 219U, chartInstance->c1_sfEvent);

        c1_Clutch_setValue(chartInstance, 0U);

        *chartInstance->c1_stateFb = 3U;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

          chartInstance->c1_stateFb);

        _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

        chartInstance->c1_tp_RELEASE = 0U;

        chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 53U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_c_is_ACTIVE == c1_IN_RPM_LIMITER) {

        } else {

          chartInstance->c1_c_is_ACTIVE = c1_IN_RPM_LIMITER;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

            &chartInstance->c1_c_is_ACTIVE);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 5));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 15);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 5);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 4);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 4);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 54U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_RPM_LIMITER = 1U;

          *chartInstance->c1_rpmAccTarget = 0U;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 30, 2851U, (void *)

            chartInstance->c1_rpmAccTarget);

          _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_rpmAccTarget, 52U);

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 53U,

                     chartInstance->c1_sfEvent);

        _SFD_SET_DATA_VALUE_PTR(87U, (void *)&c1_c_clutchCurrVal);

        _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 58U, chartInstance->c1_sfEvent);

        _SFD_SYMBOL_SCOPE_PUSH(1U, 0U);

        _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("clutchCurrVal", &c1_c_clutchCurrVal,

          c1_k_sf_marshallOut, c1_g_sf_marshallIn);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 58U,

                     chartInstance->c1_sfEvent);

        sf_call_output_fcn_call(chartInstance->S, 16, "ramp", 0);

        c1_c_clutchCurrVal = *chartInstance->c1_b_clutchCurrVal;

        _SFD_SYMBOL_SCOPE_POP();

        _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 58U, chartInstance->c1_sfEvent);

        _SFD_UNSET_DATA_VALUE_PTR(87U);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 58U, chartInstance->c1_sfEvent);

        c1_d6 = c1_c_clutchCurrVal;

        c1_covSaturation = false;

        if (c1_d6 < 256.0) {

          if (c1_d6 >= 0.0) {

            c1_u19 = (uint8_T)c1_d6;

          } else {

            c1_covSaturation = true;

            c1_u19 = 0U;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2238U, 32U, 4U);

          }

        } else if (c1_d6 >= 256.0) {

          c1_covSaturation = true;

          c1_u19 = MAX_uint8_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2238U, 32U, 4U);

        } else {

          c1_u19 = 0U;

        }



        CV_SATURATION_EVAL(4, 53, 0, 0, c1_covSaturation);

        *chartInstance->c1_clutchCurrVal = c1_u19;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 0, 123U, (void *)

          chartInstance->c1_clutchCurrVal);

        _SFD_DATA_RANGE_CHECK_MIN_MAX((real_T)*chartInstance->c1_clutchCurrVal,

          47U, 0.0, 100.0, 2238U, 16, 23);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 53U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_RPM_LIMITER:

      CV_STATE_EVAL(51, 0, c1_IN_RPM_LIMITER);

      *chartInstance->c1_rpmAccTarget = 0U;

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 232U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(232U, (int32_T)_SFD_CCP_CALL(5U, 232U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 232U, 0, (real_T)

        *chartInstance->c1_currVhSpeed, 15.0, 0, 5U,

        *chartInstance->c1_currVhSpeed >= 15) != 0U, chartInstance->c1_sfEvent))

                  != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 232U, chartInstance->c1_sfEvent);

        sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

        chartInstance->c1_tp_RPM_LIMITER = 0U;

        chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 54U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_c_is_ACTIVE == c1_b_IN_RUNNING) {

        } else {

          chartInstance->c1_c_is_ACTIVE = c1_b_IN_RUNNING;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

            &chartInstance->c1_c_is_ACTIVE);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 4));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

            (chartInstance->c1_c_is_ACTIVE == 5));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 16);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 6);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 5);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 5);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 55U, chartInstance->c1_sfEvent);

          chartInstance->c1_c_tp_RUNNING = 1U;

          chartInstance->c1_b_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

            &chartInstance->c1_b_autoXCounter);

          _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

          c1_u20 = chartInstance->c1_b_autoXCounter;

          sf_mex_printf("%s =\\n", "autoXCounter");

          sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11,

                            c1_u20);

          c1_u21 = *chartInstance->c1_currGear;

          c1_b_covSaturation = false;

          if (c1_u21 > 255) {

            c1_b_covSaturation = true;

            c1_u21 = 255U;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2193U, 64U, 8U);

          }



          CV_SATURATION_EVAL(4, 55, 0, 0, c1_b_covSaturation);

          chartInstance->c1_lastShift = (uint8_T)c1_u21;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

            &chartInstance->c1_lastShift);

          _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

          c1_b_autoXCheckShift(chartInstance);

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 54U,

                     chartInstance->c1_sfEvent);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 54U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      break;



     case c1_b_IN_RUNNING:

      CV_STATE_EVAL(51, 0, c1_b_IN_RUNNING);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 212U,

                   chartInstance->c1_sfEvent);

      c1_b_temp = _SFD_CCP_CALL(5U, 212U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U,

        212U, 0, (real_T)*chartInstance->c1_currGear, 5.0, 0, 5U,

        *chartInstance->c1_currGear >= 5) != 0U, chartInstance->c1_sfEvent);

      if (c1_b_temp) {

        c1_b_temp = _SFD_CCP_CALL(5U, 212U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

          212U, 1, (real_T)*chartInstance->c1_currGear, 8.0, 0, 1U,

          *chartInstance->c1_currGear != 8) != 0U, chartInstance->c1_sfEvent);

      }



      c1_e_out = (CV_TRANSITION_EVAL(212U, (int32_T)c1_b_temp) != 0);

      if (c1_e_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 212U, chartInstance->c1_sfEvent);

        chartInstance->c1_c_tp_RUNNING = 0U;

        chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 5));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 55U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_LAUNCH0 != c1_IN_ACTIVE) {

        } else {

          chartInstance->c1_c_tp_ACTIVE = 0U;

          _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG, 51U,

                       chartInstance->c1_sfEvent);

          sf_call_output_fcn_disable(chartInstance->S, 16, "ramp", 0);

          _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

          chartInstance->c1_is_LAUNCH0 = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

            (chartInstance->c1_is_LAUNCH0 == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

            (chartInstance->c1_is_LAUNCH0 == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 0);

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

            &chartInstance->c1_c_is_ACTIVE);

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

        }



        if (chartInstance->c1_is_LAUNCH0 == c1_IN_STOPPING) {

        } else {

          chartInstance->c1_is_LAUNCH0 = c1_IN_STOPPING;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

            &chartInstance->c1_is_LAUNCH0);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

            (chartInstance->c1_is_LAUNCH0 == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

            (chartInstance->c1_is_LAUNCH0 == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 24);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 7);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 6);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

          chartInstance->c1_c_tp_STOPPING = 1U;

          sf_call_output_fcn_call(chartInstance->S, 5, "Efi_unsetRPMLimiter", 0);

          c1_Clutch_setValue(chartInstance, 0U);

        }

      } else {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 55U,

                     chartInstance->c1_sfEvent);

        c1_b_autoXCheckShift(chartInstance);

      }



      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 55U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_LAUNCH0 != c1_IN_ACTIVE) {

      } else {

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      }

      break;



     case c1_b_IN_START:

      CV_STATE_EVAL(51, 0, c1_b_IN_START);

      c1_c_START(chartInstance);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(51, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 51U, chartInstance->c1_sfEvent);

      break;

    }

  }

}



static void c1_c_exit_internal_ACTIVE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_c_is_ACTIVE) {

   case c1_IN_READY:

    CV_STATE_EVAL(51, 1, c1_IN_READY);

    chartInstance->c1_c_tp_READY = 0U;

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_RELEASE:

    CV_STATE_EVAL(51, 1, c1_IN_RELEASE);

    chartInstance->c1_tp_RELEASE = 0U;

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 53U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_RPM_LIMITER:

    CV_STATE_EVAL(51, 1, c1_IN_RPM_LIMITER);

    chartInstance->c1_tp_RPM_LIMITER = 0U;

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 54U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_RUNNING:

    CV_STATE_EVAL(51, 1, c1_b_IN_RUNNING);

    chartInstance->c1_c_tp_RUNNING = 0U;

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 55U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_START:

    CV_STATE_EVAL(51, 1, c1_b_IN_START);

    chartInstance->c1_c_tp_START = 0U;

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 56U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(51, 1, 0);

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_c_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i61;

  boolean_T c1_covSaturation;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 216U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(216U, (int32_T)_SFD_CCP_CALL(5U, 216U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 216U, 0, (real_T)

    chartInstance->c1_b_autoXCounter, 1.0, 0, 3U,

    chartInstance->c1_b_autoXCounter <= 1) != 0U, chartInstance->c1_sfEvent)) !=

              0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 216U, chartInstance->c1_sfEvent);

    chartInstance->c1_c_tp_START = 0U;

    chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

      (chartInstance->c1_c_is_ACTIVE == 5));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 56U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_c_is_ACTIVE == c1_IN_READY) {

    } else {

      chartInstance->c1_c_is_ACTIVE = c1_IN_READY;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

        &chartInstance->c1_c_is_ACTIVE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 5));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 20);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 3);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 2);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 2);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

      chartInstance->c1_c_tp_READY = 1U;

      c1_c_enter_atomic_READY(chartInstance);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 56U, chartInstance->c1_sfEvent);

    c1_i61 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_b_autoXCounter, 1, 2191U, 165, 1);

    c1_covSaturation = false;

    if (c1_i61 < 0) {

      c1_covSaturation = true;

      c1_i61 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2191U, 165U, 1U);

    } else {

      if (c1_i61 > 65535) {

        c1_i61 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2191U, 165U, 1U);

      }



      CV_SATURATION_EVAL(4, 56, 0, 0, c1_covSaturation);

    }



    chartInstance->c1_b_autoXCounter = (uint16_T)c1_i61;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

      &chartInstance->c1_b_autoXCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 56U, chartInstance->c1_sfEvent);

}



static void c1_c_enter_atomic_READY(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  uint16_T c1_u22;

  *chartInstance->c1_stateFb = (uint16_T)AUTOX_READY;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

    chartInstance->c1_stateFb);

  _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

  chartInstance->c1_b_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

    &chartInstance->c1_b_autoXCounter);

  _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

  c1_u22 = chartInstance->c1_b_autoXCounter;

  sf_mex_printf("%s =\\n", "autoXCounter");

  sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u22);

  c1_Clutch_setValue(chartInstance, 100U);

  c1_checkShift(chartInstance);

}



static void c1_READY(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_i62;

  boolean_T c1_covSaturation;

  boolean_T c1_temp;

  boolean_T c1_b_temp;

  c1_autoX_params c1_index;

  boolean_T c1_c_out;

  int32_T c1_i63;

  int32_T c1_param;

  real_T c1_c_clutchCurrVal;

  real_T c1_d7;

  boolean_T c1_b_covSaturation;

  uint8_T c1_u23;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 217U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(217U, (int32_T)_SFD_CCP_CALL(5U, 217U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 217U, 0, (real_T)

    chartInstance->c1_b_autoXCounter, 1.0, 0, 3U,

    chartInstance->c1_b_autoXCounter <= 1) != 0U, chartInstance->c1_sfEvent)) !=

              0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 217U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 218U,

                 chartInstance->c1_sfEvent);

    c1_temp = _SFD_CCP_CALL(5U, 218U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 218U,

      0, (real_T)(*chartInstance->c1_autoXCom)[0], (real_T)

      chartInstance->c1_lastAutoXCom, 0, 1U, (*chartInstance->c1_autoXCom)[0] !=

      chartInstance->c1_lastAutoXCom) != 0U, chartInstance->c1_sfEvent);

    if (c1_temp) {

      c1_temp = _SFD_CCP_CALL(5U, 218U, 1, ((*chartInstance->c1_autoXCom)[1] ==

        AUTOX_GO) != 0U, chartInstance->c1_sfEvent);

    }



    c1_b_temp = c1_temp;

    if (c1_b_temp) {

      c1_index = autoX_params_AUTOX_TPS_START_LIMIT;

      _SFD_SET_DATA_VALUE_PTR(86U, (void *)&c1_i63);

      _SFD_SET_DATA_VALUE_PTR(77U, (void *)&c1_index);

      _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 60U, chartInstance->c1_sfEvent);

      _SFD_SYMBOL_SCOPE_PUSH(2U, 0U);

      _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("index", &c1_index, c1_n_sf_marshallOut,

        c1_j_sf_marshallIn);

      _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("param", &c1_i63, c1_sf_marshallOut,

        c1_sf_marshallIn);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 60U,

                   chartInstance->c1_sfEvent);

      c1_i63 = 0;

      _SFD_DATA_RANGE_CHECK((real_T)c1_i63, 86U);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 230U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 231U, chartInstance->c1_sfEvent);

      c1_i63 = (*chartInstance->c1_autoX_parameters)[sf_array_bounds_check

        (sfGlobalDebugInstanceStruct, chartInstance->S, 2231U, 9, 16, 32U,

         (int32_T)c1_index, 0, 15)];

      _SFD_DATA_RANGE_CHECK((real_T)c1_i63, 86U);

      c1_param = c1_i63;

      sf_mex_printf("%s =\\n", "param");

      sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12,

                        c1_param);

      _SFD_SYMBOL_SCOPE_POP();

      _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 60U, chartInstance->c1_sfEvent);

      _SFD_UNSET_DATA_VALUE_PTR(86U);

      _SFD_UNSET_DATA_VALUE_PTR(77U);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 60U, chartInstance->c1_sfEvent);

      c1_b_temp = _SFD_CCP_CALL(5U, 218U, 2, (boolean_T)CV_RELATIONAL_EVAL(5U,

        218U, 1, (real_T)*chartInstance->c1_currTps, (real_T)c1_i63, 0, 5U,

        *chartInstance->c1_currTps >= c1_i63) != 0U, chartInstance->c1_sfEvent);

    }



    c1_c_out = (CV_TRANSITION_EVAL(218U, (int32_T)c1_b_temp) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 218U, chartInstance->c1_sfEvent);

      chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

        &chartInstance->c1_lastAutoXCom);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

      *chartInstance->c1_stateFb = (uint16_T)AUTOX_GO;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

        chartInstance->c1_stateFb);

      _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

      chartInstance->c1_c_tp_READY = 0U;

      chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_c_is_ACTIVE == c1_IN_RELEASE) {

      } else {

        chartInstance->c1_c_is_ACTIVE = c1_IN_RELEASE;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

          &chartInstance->c1_c_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 14);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 4);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 3);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 3);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 53U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_RELEASE = 1U;

        _SFD_SET_DATA_VALUE_PTR(87U, (void *)&c1_c_clutchCurrVal);

        _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 58U, chartInstance->c1_sfEvent);

        _SFD_SYMBOL_SCOPE_PUSH(1U, 0U);

        _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("clutchCurrVal", &c1_c_clutchCurrVal,

          c1_k_sf_marshallOut, c1_g_sf_marshallIn);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 58U,

                     chartInstance->c1_sfEvent);

        sf_call_output_fcn_call(chartInstance->S, 16, "ramp", 0);

        c1_c_clutchCurrVal = *chartInstance->c1_b_clutchCurrVal;

        _SFD_SYMBOL_SCOPE_POP();

        _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 58U, chartInstance->c1_sfEvent);

        _SFD_UNSET_DATA_VALUE_PTR(87U);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 58U, chartInstance->c1_sfEvent);

        c1_d7 = c1_c_clutchCurrVal;

        c1_b_covSaturation = false;

        if (c1_d7 < 256.0) {

          if (c1_d7 >= 0.0) {

            c1_u23 = (uint8_T)c1_d7;

          } else {

            c1_b_covSaturation = true;

            c1_u23 = 0U;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2238U, 32U, 4U);

          }

        } else if (c1_d7 >= 256.0) {

          c1_b_covSaturation = true;

          c1_u23 = MAX_uint8_T;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2238U, 32U, 4U);

        } else {

          c1_u23 = 0U;

        }



        CV_SATURATION_EVAL(4, 53, 0, 0, c1_b_covSaturation);

        *chartInstance->c1_clutchCurrVal = c1_u23;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 0, 123U, (void *)

          chartInstance->c1_clutchCurrVal);

        _SFD_DATA_RANGE_CHECK_MIN_MAX((real_T)*chartInstance->c1_clutchCurrVal,

          47U, 0.0, 100.0, 2238U, 16, 23);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 215U, chartInstance->c1_sfEvent);

      chartInstance->c1_c_tp_READY = 0U;

      chartInstance->c1_c_is_ACTIVE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

        (chartInstance->c1_c_is_ACTIVE == 5));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_c_is_ACTIVE == c1_IN_READY) {

      } else {

        chartInstance->c1_c_is_ACTIVE = c1_IN_READY;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

          &chartInstance->c1_c_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 20);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 3);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 2);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 2);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

        chartInstance->c1_c_tp_READY = 1U;

        c1_c_enter_atomic_READY(chartInstance);

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 52U, chartInstance->c1_sfEvent);

    c1_i62 = c1__s32_minus__(chartInstance, (int32_T)

      chartInstance->c1_b_autoXCounter, 1, 2192U, 139, 1);

    c1_covSaturation = false;

    if (c1_i62 < 0) {

      c1_covSaturation = true;

      c1_i62 = 0;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2192U, 139U, 1U);

    } else {

      if (c1_i62 > 65535) {

        c1_i62 = 65535;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2192U, 139U, 1U);

      }



      CV_SATURATION_EVAL(4, 52, 0, 0, c1_covSaturation);

    }



    chartInstance->c1_b_autoXCounter = (uint16_T)c1_i62;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

      &chartInstance->c1_b_autoXCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

    c1_checkShift(chartInstance);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 52U, chartInstance->c1_sfEvent);

}



static void c1_c_DEFAULT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  uint16_T c1_u24;

  boolean_T c1_c_out;

  uint16_T c1_u25;

  boolean_T guard1 = false;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 183U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 183U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 183U, 0,

    (real_T)(*chartInstance->c1_autoXCom)[0], (real_T)

    chartInstance->c1_lastAutoXCom, 0, 1U, (*chartInstance->c1_autoXCom)[0] !=

    chartInstance->c1_lastAutoXCom) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 183U, 1, ((*chartInstance->c1_autoXCom)[1] ==

      AUTOX_READY) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(183U, (int32_T)c1_temp) != 0);

  guard1 = false;

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 183U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastAutoXCom = (*chartInstance->c1_autoXCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

      &chartInstance->c1_lastAutoXCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastAutoXCom, 2U);

    c1_u24 = chartInstance->c1_lastAutoXCom;

    sf_mex_printf("%s =\\n", "lastAutoXCom");

    sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11, c1_u24);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 188U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(188U, (int32_T)_SFD_CCP_CALL(5U, 188U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 188U, 0, (real_T)

      *chartInstance->c1_pidSubMode, 0.0, 0, 0U, *chartInstance->c1_pidSubMode ==

      0) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 188U, chartInstance->c1_sfEvent);

      chartInstance->c1_c_tp_DEFAULT = 0U;

      chartInstance->c1_is_ACCELERATION_PID = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_ACCELERATION_PID = c1_IN_LAUNCH0;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

        &chartInstance->c1_is_ACCELERATION_PID);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

        (chartInstance->c1_is_ACCELERATION_PID == 2));

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 50U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_LAUNCH0 = 1U;

      chartInstance->c1_b_autoXCounter = 0U;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

        &chartInstance->c1_b_autoXCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

      chartInstance->c1_b_autoX_clutchValue = 0.0;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 71, 2171U, (void *)

        &chartInstance->c1_b_autoX_clutchValue);

      _SFD_DATA_RANGE_CHECK(chartInstance->c1_b_autoX_clutchValue, 14U);

      chartInstance->c1_b_autoX_clutchStep = 0.0;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 72, 2172U, (void *)

        &chartInstance->c1_b_autoX_clutchStep);

      _SFD_DATA_RANGE_CHECK(chartInstance->c1_b_autoX_clutchStep, 13U);

      chartInstance->c1_b_autoX_dtRelease = 0;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 73, 2173U, (void *)

        &chartInstance->c1_b_autoX_dtRelease);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoX_dtRelease, 15U);

      if (chartInstance->c1_is_LAUNCH0 == c1_IN_ACTIVE) {

      } else {

        chartInstance->c1_is_LAUNCH0 = c1_IN_ACTIVE;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

          &chartInstance->c1_is_LAUNCH0);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

          (chartInstance->c1_is_LAUNCH0 == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

          (chartInstance->c1_is_LAUNCH0 == 2));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

        chartInstance->c1_c_tp_ACTIVE = 1U;

        sf_call_output_fcn_enable(chartInstance->S, 16, "ramp", 0);

      }



      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 214U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_c_is_ACTIVE == c1_b_IN_START) {

      } else {

        chartInstance->c1_c_is_ACTIVE = c1_b_IN_START;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

          &chartInstance->c1_c_is_ACTIVE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

          (chartInstance->c1_c_is_ACTIVE == 5));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 1, 418U, 12);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 12, 1157U, 2);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 14, 2174U, 1);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 15, 2182U, 1);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 56U, chartInstance->c1_sfEvent);

        chartInstance->c1_c_tp_START = 1U;

        *chartInstance->c1_stateFb = (uint16_T)AUTOX_READY;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

          chartInstance->c1_stateFb);

        _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

        chartInstance->c1_b_autoXCounter = c1_const_AUTOX_WORK_RATE_ms;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

          &chartInstance->c1_b_autoXCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_b_autoXCounter, 12U);

        c1_u25 = chartInstance->c1_b_autoXCounter;

        sf_mex_printf("%s =\\n", "autoXCounter");

        sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 11,

                          c1_u25);

        sf_call_output_fcn_call(chartInstance->S, 4, "Efi_setRPMLimiter", 0);

        c1_Clutch_setValue(chartInstance, 100U);

      }

    } else {

      guard1 = true;

    }

  } else {

    guard1 = true;

  }



  if (guard1) {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 49U, chartInstance->c1_sfEvent);

    *chartInstance->c1_stateFb = (uint16_T)AUTOX_DEFAULT;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

      chartInstance->c1_stateFb);

    _SFD_DATA_RANGE_CHECK((real_T)*chartInstance->c1_stateFb, 49U);

    c1_checkShift(chartInstance);

    c1_checkClutch(chartInstance);

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 49U, chartInstance->c1_sfEvent);

}



static void c1_NEUTRAL_STATE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_temp;

  boolean_T c1_b_temp;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  boolean_T c1_g_out;

  boolean_T guard1 = false;

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 79U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_NEUTRAL_STATE) {

   case c1_IN_NEUTRAL:

    CV_STATE_EVAL(79, 0, c1_IN_NEUTRAL);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 14U,

                 chartInstance->c1_sfEvent);

    c1_b_out = (CV_TRANSITION_EVAL(14U, (int32_T)_SFD_CCP_CALL(5U, 14U, 0,

      (chartInstance->c1_sfEvent == c1_event_GearshiftUp) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    guard1 = false;

    if (c1_b_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 14U, chartInstance->c1_sfEvent);

      guard1 = true;

    } else {

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 92U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(92U, (int32_T)_SFD_CCP_CALL(5U, 92U, 0,

        (chartInstance->c1_sfEvent == c1_event_GearshiftDown) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 92U, chartInstance->c1_sfEvent);

        guard1 = true;

      } else {

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 180U,

                     chartInstance->c1_sfEvent);

        c1_g_out = (CV_TRANSITION_EVAL(180U, (int32_T)_SFD_CCP_CALL(5U, 180U, 0,

          (boolean_T)CV_RELATIONAL_EVAL(5U, 180U, 0, (real_T)

          *chartInstance->c1_currGear, 0.0, 0, 1U, *chartInstance->c1_currGear

          != 0) != 0U, chartInstance->c1_sfEvent)) != 0);

        if (c1_g_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 180U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_NEUTRAL = 0U;

          chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 4));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

          chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_NEUTRAL;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

            &chartInstance->c1_is_NEUTRAL_STATE);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 3));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

            (chartInstance->c1_is_NEUTRAL_STATE == 4));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 3);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 81U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_NO_NEUTRAL = 1U;

        } else {

          _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 80U,

                       chartInstance->c1_sfEvent);

        }

      }

    }



    if (guard1) {

      chartInstance->c1_tp_NEUTRAL = 0U;

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_UNSET_NEUTRAL;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

        &chartInstance->c1_is_NEUTRAL_STATE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 2);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 83U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_UNSET_NEUTRAL = 1U;

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 80U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_NO_NEUTRAL:

    CV_STATE_EVAL(79, 0, c1_IN_NO_NEUTRAL);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 16U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(16U, (int32_T)_SFD_CCP_CALL(5U, 16U, 0,

      (chartInstance->c1_sfEvent == c1_event_GearshiftSetNeutral) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 16U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_NO_NEUTRAL = 0U;

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 81U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_SET_NEUTRAL;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

        &chartInstance->c1_is_NEUTRAL_STATE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 4);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 82U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_SET_NEUTRAL = 1U;

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 81U,

                   chartInstance->c1_sfEvent);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 81U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_SET_NEUTRAL:

    CV_STATE_EVAL(79, 0, c1_IN_SET_NEUTRAL);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 17U,

                 chartInstance->c1_sfEvent);

    c1_temp = _SFD_CCP_CALL(5U, 17U, 0, (chartInstance->c1_is_GEARSHIFT ==

      c1_IN_DOWN_END) != 0U, chartInstance->c1_sfEvent);

    if (!c1_temp) {

      c1_temp = _SFD_CCP_CALL(5U, 17U, 1, (chartInstance->c1_is_GEARSHIFT ==

        c1_IN_UP_END) != 0U, chartInstance->c1_sfEvent);

    }



    c1_e_out = (CV_TRANSITION_EVAL(17U, (int32_T)c1_temp) != 0);

    if (c1_e_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 17U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_SET_NEUTRAL = 0U;

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 82U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NEUTRAL;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

        &chartInstance->c1_is_NEUTRAL_STATE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 1);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_NEUTRAL = 1U;

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 82U,

                   chartInstance->c1_sfEvent);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 82U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_UNSET_NEUTRAL:

    CV_STATE_EVAL(79, 0, c1_IN_UNSET_NEUTRAL);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 15U,

                 chartInstance->c1_sfEvent);

    c1_b_temp = _SFD_CCP_CALL(5U, 15U, 0, (chartInstance->c1_is_GEARSHIFT ==

      c1_IN_DOWN_END) != 0U, chartInstance->c1_sfEvent);

    if (!c1_b_temp) {

      c1_b_temp = _SFD_CCP_CALL(5U, 15U, 1, (chartInstance->c1_is_GEARSHIFT ==

        c1_IN_UP_END) != 0U, chartInstance->c1_sfEvent);

    }



    c1_f_out = (CV_TRANSITION_EVAL(15U, (int32_T)c1_b_temp) != 0);

    if (c1_f_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_UNSET_NEUTRAL = 0U;

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 83U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_NEUTRAL;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

        &chartInstance->c1_is_NEUTRAL_STATE);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

        (chartInstance->c1_is_NEUTRAL_STATE == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 36, 31U, 3);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 81U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_NO_NEUTRAL = 1U;

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 83U,

                   chartInstance->c1_sfEvent);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 83U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(79, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_NEUTRAL_STATE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

      (chartInstance->c1_is_NEUTRAL_STATE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

      (chartInstance->c1_is_NEUTRAL_STATE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

      (chartInstance->c1_is_NEUTRAL_STATE == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

      (chartInstance->c1_is_NEUTRAL_STATE == 4));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

    break;

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 79U, chartInstance->c1_sfEvent);

}



static void c1_GEARSHIFT(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 7U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_GEARSHIFT) {

   case c1_IN_DOWNSHIFTING:

    CV_STATE_EVAL(7, 0, c1_IN_DOWNSHIFTING);

    c1_DOWNSHIFTING(chartInstance);

    break;



   case c1_IN_DOWN_END:

    CV_STATE_EVAL(7, 0, c1_IN_DOWN_END);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 18U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_DOWN_END = 0U;

    chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 18U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_GEARSHIFT = c1_IN_IDLE;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

      &chartInstance->c1_is_GEARSHIFT);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 2);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_IDLE = 1U;

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 18U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_IDLE:

    CV_STATE_EVAL(7, 0, c1_IN_IDLE);

    c1_IDLE(chartInstance);

    break;



   case c1_IN_INIT:

    CV_STATE_EVAL(7, 0, c1_IN_INIT);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 1U, chartInstance->c1_sfEvent);

    chartInstance->c1_b_tp_INIT = 0U;

    chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 21U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_GEARSHIFT = c1_IN_IDLE;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

      &chartInstance->c1_is_GEARSHIFT);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 2);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_IDLE = 1U;

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 21U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_UPSHIFTING:

    CV_STATE_EVAL(7, 0, c1_IN_UPSHIFTING);

    c1_UPSHIFTING(chartInstance);

    break;



   case c1_IN_UP_END:

    CV_STATE_EVAL(7, 0, c1_IN_UP_END);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 8U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_UP_END = 0U;

    chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 33U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_GEARSHIFT = c1_IN_IDLE;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

      &chartInstance->c1_is_GEARSHIFT);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 2);

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_IDLE = 1U;

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 33U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(7, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 8U, chartInstance->c1_sfEvent);

    break;

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 7U, chartInstance->c1_sfEvent);

}



static void c1_UPSHIFTING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  int32_T c1_q0;

  int32_T c1_b_q0;

  int32_T c1_c_q0;

  int32_T c1_q1;

  int32_T c1_b_q1;

  int32_T c1_c_q1;

  boolean_T c1_covSaturation;

  boolean_T c1_b_covSaturation;

  boolean_T c1_c_covSaturation;

  int32_T c1_qY;

  int32_T c1_b_qY;

  int32_T c1_c_qY;

  boolean_T c1_temp;

  boolean_T c1_e_out;

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 22U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_UPSHIFTING) {

   case c1_IN_UP_BRAKE:

    CV_STATE_EVAL(22, 0, c1_IN_UP_BRAKE);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 7U, chartInstance->c1_sfEvent);

    c1_b_out = (CV_TRANSITION_EVAL(7U, (int32_T)_SFD_CCP_CALL(5U, 7U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 7U, 0, (real_T)

      chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter

      == 1) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_b_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 7U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_UP_BRAKE = 0U;

      chartInstance->c1_is_UPSHIFTING = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 23U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_UPSHIFTING = 0U;

      chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 5));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 6));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

        &chartInstance->c1_is_UPSHIFTING);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 22U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_GEARSHIFT == c1_IN_UP_END) {

      } else {

        chartInstance->c1_is_GEARSHIFT = c1_IN_UP_END;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

          &chartInstance->c1_is_GEARSHIFT);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 5));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 6));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 10);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 33U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_UP_END = 1U;

        sf_call_output_fcn_call(chartInstance->S, 10, "Gearshift_free", 0);

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 23U,

                   chartInstance->c1_sfEvent);

      c1_q0 = chartInstance->c1_ticksCounter;

      c1_q1 = 1;

      c1_covSaturation = false;

      if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

        c1_covSaturation = true;

        c1_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 12U, 114U, 1U);

      } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

        c1_covSaturation = true;

        c1_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 12U, 114U, 1U);

      } else {

        c1_qY = c1_q0 - c1_q1;

      }



      CV_SATURATION_EVAL(4, 23, 0, 0, c1_covSaturation);

      chartInstance->c1_ticksCounter = c1_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 23U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_GEARSHIFT != c1_IN_UPSHIFTING) {

    } else {

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 22U, chartInstance->c1_sfEvent);

    }

    break;



   case c1_IN_UP_PUSH:

    CV_STATE_EVAL(22, 0, c1_IN_UP_PUSH);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 5U, chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(5U, (int32_T)_SFD_CCP_CALL(5U, 5U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 5U, 0, (real_T)

      chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter

      == 1) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 5U, chartInstance->c1_sfEvent);

      c1_exit_internal_UP_PUSH(chartInstance);

      chartInstance->c1_tp_UP_PUSH = 0U;

      chartInstance->c1_is_UPSHIFTING = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 57, 10U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 57, 10U, (void *)

        &chartInstance->c1_is_UP_PUSH);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 24U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_REBOUND) {

      } else {

        chartInstance->c1_is_UPSHIFTING = c1_IN_UP_REBOUND;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

          &chartInstance->c1_is_UPSHIFTING);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 4));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 27U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_UP_REBOUND = 1U;

        chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

          &chartInstance->c1_ticksCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      }



      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 65U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 64U,

                   chartInstance->c1_sfEvent);

      c1_temp = _SFD_CCP_CALL(5U, 64U, 0, (chartInstance->c1_is_NEUTRAL_STATE ==

        c1_IN_SET_NEUTRAL) != 0U, chartInstance->c1_sfEvent);

      if (c1_temp) {

        c1_temp = _SFD_CCP_CALL(5U, 64U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

          64U, 0, (real_T)*chartInstance->c1_clutchCurrVal, 80.0, 0, 3U,

          *chartInstance->c1_clutchCurrVal <= 80) != 0U,

          chartInstance->c1_sfEvent);

      }



      c1_e_out = (CV_TRANSITION_EVAL(64U, (int32_T)c1_temp) != 0);

      if (c1_e_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 64U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_UP_REBOUND == c1_IN_SettingNeutral) {

        } else {

          chartInstance->c1_is_UP_REBOUND = c1_IN_SettingNeutral;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 60, 11U, (void *)

            &chartInstance->c1_is_UP_REBOUND);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

            (chartInstance->c1_is_UP_REBOUND == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

            (chartInstance->c1_is_UP_REBOUND == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 7);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 5);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 60, 11U, 1);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 29U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_SettingNeutral = 1U;

          c1_Clutch_setValue(chartInstance, 0U);

          sf_call_output_fcn_call(chartInstance->S, 6, "Gearshift_rebound", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 66U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_UP_REBOUND == c1_IN_Default) {

        } else {

          chartInstance->c1_is_UP_REBOUND = c1_IN_Default;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 60, 11U, (void *)

            &chartInstance->c1_is_UP_REBOUND);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

            (chartInstance->c1_is_UP_REBOUND == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

            (chartInstance->c1_is_UP_REBOUND == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 8);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 6);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 60, 11U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

          chartInstance->c1_tp_Default = 1U;

          sf_call_output_fcn_call(chartInstance->S, 6, "Gearshift_rebound", 0);

        }

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 24U,

                   chartInstance->c1_sfEvent);

      c1_b_q0 = chartInstance->c1_ticksCounter;

      c1_b_q1 = 1;

      c1_b_covSaturation = false;

      if ((c1_b_q1 < 0) && (c1_b_q0 > c1_b_q1 + MAX_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 10U, 89U, 1U);

      } else if ((c1_b_q1 > 0) && (c1_b_q0 < c1_b_q1 + MIN_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 10U, 89U, 1U);

      } else {

        c1_b_qY = c1_b_q0 - c1_b_q1;

      }



      CV_SATURATION_EVAL(4, 24, 0, 0, c1_b_covSaturation);

      chartInstance->c1_ticksCounter = c1_b_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      switch (chartInstance->c1_is_UP_PUSH) {

       case c1_IN_CutOff:

        CV_STATE_EVAL(24, 0, c1_IN_CutOff);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 25U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 25U, chartInstance->c1_sfEvent);

        break;



       case c1_b_IN_Default:

        CV_STATE_EVAL(24, 0, c1_b_IN_Default);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 26U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 26U, chartInstance->c1_sfEvent);

        break;



       default:

        CV_STATE_EVAL(24, 0, 0);



        /* Unreachable state, for coverage only */

        chartInstance->c1_is_UP_PUSH = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

          (chartInstance->c1_is_UP_PUSH == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

          (chartInstance->c1_is_UP_PUSH == 2));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

        break;

      }

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 24U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 22U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_UP_REBOUND:

    CV_STATE_EVAL(22, 0, c1_IN_UP_REBOUND);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 6U, chartInstance->c1_sfEvent);

    c1_d_out = (CV_TRANSITION_EVAL(6U, (int32_T)_SFD_CCP_CALL(5U, 6U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 6U, 0, (real_T)

      chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter

      == 1) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_d_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 6U, chartInstance->c1_sfEvent);

      c1_exit_internal_UP_REBOUND(chartInstance);

      chartInstance->c1_tp_UP_REBOUND = 0U;

      chartInstance->c1_is_UPSHIFTING = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 60, 11U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 60, 11U, (void *)

        &chartInstance->c1_is_UP_REBOUND);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 27U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_BRAKE) {

      } else {

        chartInstance->c1_is_UPSHIFTING = c1_IN_UP_BRAKE;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

          &chartInstance->c1_is_UPSHIFTING);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

          (chartInstance->c1_is_UPSHIFTING == 4));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 9);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 7);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 23U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_UP_BRAKE = 1U;

        chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

          &chartInstance->c1_ticksCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

        sf_call_output_fcn_call(chartInstance->S, 9, "Gearshift_brake", 0);

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 27U,

                   chartInstance->c1_sfEvent);

      c1_c_q0 = chartInstance->c1_ticksCounter;

      c1_c_q1 = 1;

      c1_c_covSaturation = false;

      if ((c1_c_q1 < 0) && (c1_c_q0 > c1_c_q1 + MAX_int32_T)) {

        c1_c_covSaturation = true;

        c1_c_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 11U, 92U, 1U);

      } else if ((c1_c_q1 > 0) && (c1_c_q0 < c1_c_q1 + MIN_int32_T)) {

        c1_c_covSaturation = true;

        c1_c_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 11U, 92U, 1U);

      } else {

        c1_c_qY = c1_c_q0 - c1_c_q1;

      }



      CV_SATURATION_EVAL(4, 27, 0, 0, c1_c_covSaturation);

      chartInstance->c1_ticksCounter = c1_c_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      switch (chartInstance->c1_is_UP_REBOUND) {

       case c1_IN_Default:

        CV_STATE_EVAL(27, 0, c1_IN_Default);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 28U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 28U, chartInstance->c1_sfEvent);

        break;



       case c1_IN_SettingNeutral:

        CV_STATE_EVAL(27, 0, c1_IN_SettingNeutral);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 29U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 29U, chartInstance->c1_sfEvent);

        break;



       default:

        CV_STATE_EVAL(27, 0, 0);



        /* Unreachable state, for coverage only */

        chartInstance->c1_is_UP_REBOUND = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

          (chartInstance->c1_is_UP_REBOUND == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

          (chartInstance->c1_is_UP_REBOUND == 2));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

        break;

      }

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 27U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 22U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_UP_START:

    CV_STATE_EVAL(22, 0, c1_IN_UP_START);

    c1_UP_START(chartInstance);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 22U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(22, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_UPSHIFTING = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 4));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 23U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 22U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_exit_internal_UP_REBOUND(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_UP_REBOUND) {

   case c1_IN_Default:

    CV_STATE_EVAL(27, 1, c1_IN_Default);

    chartInstance->c1_tp_Default = 0U;

    chartInstance->c1_is_UP_REBOUND = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

      (chartInstance->c1_is_UP_REBOUND == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

      (chartInstance->c1_is_UP_REBOUND == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_SettingNeutral:

    CV_STATE_EVAL(27, 1, c1_IN_SettingNeutral);

    chartInstance->c1_tp_SettingNeutral = 0U;

    chartInstance->c1_is_UP_REBOUND = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

      (chartInstance->c1_is_UP_REBOUND == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

      (chartInstance->c1_is_UP_REBOUND == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 29U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(27, 1, 0);

    chartInstance->c1_is_UP_REBOUND = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

      (chartInstance->c1_is_UP_REBOUND == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

      (chartInstance->c1_is_UP_REBOUND == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_exit_internal_UP_PUSH(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_UP_PUSH) {

   case c1_IN_CutOff:

    CV_STATE_EVAL(24, 1, c1_IN_CutOff);

    chartInstance->c1_tp_CutOff = 0U;

    chartInstance->c1_is_UP_PUSH = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

      (chartInstance->c1_is_UP_PUSH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

      (chartInstance->c1_is_UP_PUSH == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_Default:

    CV_STATE_EVAL(24, 1, c1_b_IN_Default);

    chartInstance->c1_b_tp_Default = 0U;

    chartInstance->c1_is_UP_PUSH = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

      (chartInstance->c1_is_UP_PUSH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

      (chartInstance->c1_is_UP_PUSH == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 26U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(24, 1, 0);

    chartInstance->c1_is_UP_PUSH = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

      (chartInstance->c1_is_UP_PUSH == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

      (chartInstance->c1_is_UP_PUSH == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_UP_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_covSaturation;

  int32_T c1_qY;

  boolean_T c1_c_out;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 4U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(4U, (int32_T)_SFD_CCP_CALL(5U, 4U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 4U, 0, (real_T)

    chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter ==

    1) != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 4U, chartInstance->c1_sfEvent);

    c1_exit_internal_UP_START(chartInstance);

    chartInstance->c1_tp_UP_START = 0U;

    chartInstance->c1_is_UPSHIFTING = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

      (chartInstance->c1_is_UPSHIFTING == 4));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 63, 9U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 63, 9U, (void *)

      &chartInstance->c1_is_UP_START);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 30U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_PUSH) {

    } else {

      chartInstance->c1_is_UPSHIFTING = c1_IN_UP_PUSH;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

        &chartInstance->c1_is_UPSHIFTING);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 4));

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 24U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_UP_PUSH = 1U;

      chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    }



    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 75U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 77U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(77U, !_SFD_CCP_CALL(5U, 77U, 0,

      (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 77U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_UP_PUSH == c1_IN_CutOff) {

      } else {

        chartInstance->c1_is_UP_PUSH = c1_IN_CutOff;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 57, 10U, (void *)

          &chartInstance->c1_is_UP_PUSH);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

          (chartInstance->c1_is_UP_PUSH == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

          (chartInstance->c1_is_UP_PUSH == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 5);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 3);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 57, 10U, 1);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_CutOff = 1U;

        sf_call_output_fcn_call(chartInstance->S, 3, "Efi_unsetCut", 0);

        sf_call_output_fcn_call(chartInstance->S, 7, "Gearshift_up_push", 0);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 76U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_UP_PUSH == c1_b_IN_Default) {

      } else {

        chartInstance->c1_is_UP_PUSH = c1_b_IN_Default;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 57, 10U, (void *)

          &chartInstance->c1_is_UP_PUSH);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

          (chartInstance->c1_is_UP_PUSH == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

          (chartInstance->c1_is_UP_PUSH == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 17);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 4);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 57, 10U, 2);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 26U, chartInstance->c1_sfEvent);

        chartInstance->c1_b_tp_Default = 1U;

        sf_call_output_fcn_call(chartInstance->S, 7, "Gearshift_up_push", 0);

      }

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 30U, chartInstance->c1_sfEvent);

    c1_q0 = chartInstance->c1_ticksCounter;

    c1_q1 = 1;

    c1_covSaturation = false;

    if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MAX_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 9U, 94U, 1U);

    } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MIN_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 9U, 94U, 1U);

    } else {

      c1_qY = c1_q0 - c1_q1;

    }



    CV_SATURATION_EVAL(4, 30, 1, 0, c1_covSaturation);

    chartInstance->c1_ticksCounter = c1_qY;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

      &chartInstance->c1_ticksCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    switch (chartInstance->c1_is_UP_START) {

     case c1_IN_Default:

      CV_STATE_EVAL(30, 0, c1_IN_Default);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 31U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 31U, chartInstance->c1_sfEvent);

      break;



     case c1_IN_SettingNeutral:

      CV_STATE_EVAL(30, 0, c1_IN_SettingNeutral);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 32U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 32U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(30, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_UP_START = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

        (chartInstance->c1_is_UP_START == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

        (chartInstance->c1_is_UP_START == 2));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

      break;

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 30U, chartInstance->c1_sfEvent);

}



static void c1_exit_internal_UP_START(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_UP_START) {

   case c1_IN_Default:

    CV_STATE_EVAL(30, 1, c1_IN_Default);

    chartInstance->c1_c_tp_Default = 0U;

    chartInstance->c1_is_UP_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

      (chartInstance->c1_is_UP_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

      (chartInstance->c1_is_UP_START == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_SettingNeutral:

    CV_STATE_EVAL(30, 1, c1_IN_SettingNeutral);

    chartInstance->c1_b_tp_SettingNeutral = 0U;

    chartInstance->c1_is_UP_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

      (chartInstance->c1_is_UP_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

      (chartInstance->c1_is_UP_START == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 32U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(30, 1, 0);

    chartInstance->c1_is_UP_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

      (chartInstance->c1_is_UP_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

      (chartInstance->c1_is_UP_START == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_IDLE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_temp;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_c_temp;

  boolean_T c1_d_temp;

  boolean_T c1_d_out;

  int32_T c1_q0;

  boolean_T c1_e_out;

  int32_T c1_q1;

  boolean_T c1_covSaturation;

  boolean_T c1_e_temp;

  int32_T c1_qY;

  boolean_T c1_f_out;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 2U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 2U, 0, (chartInstance->c1_sfEvent ==

    c1_event_GearshiftUp) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_b_temp = _SFD_CCP_CALL(5U, 2U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U, 2U, 0,

      (real_T)*chartInstance->c1_currGear, 5.0, 0, 2U,

      *chartInstance->c1_currGear < 5) != 0U, chartInstance->c1_sfEvent);

    if (!c1_b_temp) {

      c1_b_temp = _SFD_CCP_CALL(5U, 2U, 2, (boolean_T)CV_RELATIONAL_EVAL(5U, 2U,

        1, (real_T)*chartInstance->c1_currGear, 8.0, 0, 0U,

        *chartInstance->c1_currGear == 8) != 0U, chartInstance->c1_sfEvent);

    }



    c1_temp = c1_b_temp;

  }



  c1_b_out = (CV_TRANSITION_EVAL(2U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 2U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_IDLE = 0U;

    chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

    chartInstance->c1_is_GEARSHIFT = c1_IN_UPSHIFTING;

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

      &chartInstance->c1_is_GEARSHIFT);

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 4));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 5));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

      (chartInstance->c1_is_GEARSHIFT == 6));

    _SFD_CS_CALL(STATE_ACTIVE_TAG, 22U, chartInstance->c1_sfEvent);

    chartInstance->c1_tp_UPSHIFTING = 1U;

    if (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_START) {

    } else {

      chartInstance->c1_is_UPSHIFTING = c1_IN_UP_START;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

        &chartInstance->c1_is_UPSHIFTING);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

        (chartInstance->c1_is_UPSHIFTING == 4));

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 30U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_UP_START = 1U;

      c1_q0 = c1_Gearshift_getTime(chartInstance);

      c1_q1 = 1;

      c1_covSaturation = false;

      if ((c1_q1 < 0) && (c1_q0 < MIN_int32_T - c1_q1)) {

        c1_covSaturation = true;

        c1_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 9U, 52U, 1U);

      } else if ((c1_q1 > 0) && (c1_q0 > MAX_int32_T - c1_q1)) {

        c1_covSaturation = true;

        c1_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 9U, 52U, 1U);

      } else {

        c1_qY = c1_q0 + c1_q1;

      }



      CV_SATURATION_EVAL(4, 30, 0, 0, c1_covSaturation);

      chartInstance->c1_ticksCounter = c1_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    }



    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 61U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 62U,

                 chartInstance->c1_sfEvent);

    c1_c_temp = _SFD_CCP_CALL(5U, 62U, 0, (chartInstance->c1_is_NEUTRAL_STATE ==

      c1_IN_SET_NEUTRAL) != 0U, chartInstance->c1_sfEvent);

    if (c1_c_temp) {

      c1_c_temp = _SFD_CCP_CALL(5U, 62U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

        62U, 0, (real_T)*chartInstance->c1_clutchCurrVal, 80.0, 0, 3U,

        *chartInstance->c1_clutchCurrVal <= 80) != 0U, chartInstance->c1_sfEvent);

    }



    c1_d_out = (CV_TRANSITION_EVAL(62U, (int32_T)c1_c_temp) != 0);

    if (c1_d_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 62U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_UP_START == c1_IN_SettingNeutral) {

      } else {

        chartInstance->c1_is_UP_START = c1_IN_SettingNeutral;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 63, 9U, (void *)

          &chartInstance->c1_is_UP_START);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

          (chartInstance->c1_is_UP_START == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

          (chartInstance->c1_is_UP_START == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 7);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 5);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 63, 9U, 1);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 32U, chartInstance->c1_sfEvent);

        chartInstance->c1_b_tp_SettingNeutral = 1U;

        c1_Clutch_setValue(chartInstance, 80U);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 63U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_UP_START == c1_IN_Default) {

      } else {

        chartInstance->c1_is_UP_START = c1_IN_Default;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 63, 9U, (void *)

          &chartInstance->c1_is_UP_START);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

          (chartInstance->c1_is_UP_START == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

          (chartInstance->c1_is_UP_START == 2));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 8);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 55, 693U, 6);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 63, 9U, 2);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

        chartInstance->c1_c_tp_Default = 1U;

        sf_call_output_fcn_call(chartInstance->S, 2, "Efi_setCut", 0);

      }

    }

  } else {

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 3U, chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(3U, (int32_T)_SFD_CCP_CALL(5U, 3U, 0,

      (chartInstance->c1_sfEvent == c1_event_GearshiftDown) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 3U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_IDLE = 0U;

      chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 5));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 6));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

      chartInstance->c1_is_GEARSHIFT = c1_IN_DOWNSHIFTING;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

        &chartInstance->c1_is_GEARSHIFT);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 5));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 6));

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 8U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_DOWNSHIFTING = 1U;

      if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_START) {

      } else {

        chartInstance->c1_is_DOWNSHIFTING = c1_IN_DOWN_START;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

          &chartInstance->c1_is_DOWNSHIFTING);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 4));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 14U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_DOWN_START = 1U;

        chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

          &chartInstance->c1_ticksCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      }



      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 68U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 67U,

                   chartInstance->c1_sfEvent);

      c1_d_temp = _SFD_CCP_CALL(5U, 67U, 0, (chartInstance->c1_is_NEUTRAL_STATE ==

        c1_IN_SET_NEUTRAL) != 0U, chartInstance->c1_sfEvent);

      if (c1_d_temp) {

        c1_d_temp = _SFD_CCP_CALL(5U, 67U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

          67U, 0, (real_T)*chartInstance->c1_clutchCurrVal, 80.0, 0, 3U,

          *chartInstance->c1_clutchCurrVal <= 80) != 0U,

          chartInstance->c1_sfEvent);

      }



      c1_e_out = (CV_TRANSITION_EVAL(67U, (int32_T)c1_d_temp) != 0);

      if (c1_e_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 67U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_DOWN_START == c1_b_IN_SettingNeutral) {

        } else {

          chartInstance->c1_is_DOWN_START = c1_b_IN_SettingNeutral;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 48, 14U, (void *)

            &chartInstance->c1_is_DOWN_START);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

            (chartInstance->c1_is_DOWN_START == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

            (chartInstance->c1_is_DOWN_START == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

            (chartInstance->c1_is_DOWN_START == 3));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 11);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 1);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 48, 14U, 1);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 17U, chartInstance->c1_sfEvent);

          chartInstance->c1_c_tp_SettingNeutral = 1U;

          c1_Clutch_setValue(chartInstance, 80U);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 70U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 69U,

                     chartInstance->c1_sfEvent);

        c1_e_temp = !_SFD_CCP_CALL(5U, 69U, 0,

          (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_UNSET_NEUTRAL) != 0U,

          chartInstance->c1_sfEvent);

        if (c1_e_temp) {

          c1_e_temp = _SFD_CCP_CALL(5U, 69U, 1, (boolean_T)CV_RELATIONAL_EVAL(5U,

            69U, 0, (real_T)*chartInstance->c1_clutchCurrVal, 70.0, 0, 3U,

            *chartInstance->c1_clutchCurrVal <= 70) != 0U,

            chartInstance->c1_sfEvent);

        }



        c1_f_out = (CV_TRANSITION_EVAL(69U, (int32_T)c1_e_temp) != 0);

        if (c1_f_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 69U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 210U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_DOWN_START == c1_IN_ChangeClutch) {

          } else {

            chartInstance->c1_is_DOWN_START = c1_IN_ChangeClutch;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 48, 14U, (void *)

              &chartInstance->c1_is_DOWN_START);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

              (chartInstance->c1_is_DOWN_START == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

              (chartInstance->c1_is_DOWN_START == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

              (chartInstance->c1_is_DOWN_START == 3));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 16);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 6);

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 48, 14U, 2);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

            chartInstance->c1_tp_ChangeClutch = 1U;

            c1_Clutch_setValue(chartInstance, 70U);

          }

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 71U, chartInstance->c1_sfEvent);

          chartInstance->c1_is_DOWN_START = c1_b_IN_Default;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 48, 14U, (void *)

            &chartInstance->c1_is_DOWN_START);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

            (chartInstance->c1_is_DOWN_START == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

            (chartInstance->c1_is_DOWN_START == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

            (chartInstance->c1_is_DOWN_START == 3));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 17);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 7);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 48, 14U, 3);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 16U, chartInstance->c1_sfEvent);

          chartInstance->c1_d_tp_Default = 1U;

        }

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 20U,

                   chartInstance->c1_sfEvent);

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 20U, chartInstance->c1_sfEvent);

}



static void c1_DOWNSHIFTING(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  int32_T c1_q0;

  int32_T c1_b_q0;

  int32_T c1_c_q0;

  int32_T c1_q1;

  int32_T c1_b_q1;

  int32_T c1_c_q1;

  boolean_T c1_covSaturation;

  boolean_T c1_b_covSaturation;

  boolean_T c1_c_covSaturation;

  int32_T c1_qY;

  int32_T c1_b_qY;

  int32_T c1_c_qY;

  boolean_T c1_e_out;

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 8U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_DOWNSHIFTING) {

   case c1_IN_DOWN_BRAKE:

    CV_STATE_EVAL(8, 0, c1_IN_DOWN_BRAKE);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 12U,

                 chartInstance->c1_sfEvent);

    c1_b_out = (CV_TRANSITION_EVAL(12U, (int32_T)_SFD_CCP_CALL(5U, 12U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 12U, 0, (real_T)

      chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter

      == 1) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_b_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 12U, chartInstance->c1_sfEvent);

      c1_exit_internal_DOWN_BRAKE(chartInstance);

      chartInstance->c1_tp_DOWN_BRAKE = 0U;

      chartInstance->c1_is_DOWNSHIFTING = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 43, 17U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 43, 17U, (void *)

        &chartInstance->c1_is_DOWN_BRAKE);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 9U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_DOWNSHIFTING = 0U;

      chartInstance->c1_is_GEARSHIFT = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 4));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 5));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

        (chartInstance->c1_is_GEARSHIFT == 6));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 0);

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

        &chartInstance->c1_is_DOWNSHIFTING);

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 8U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_GEARSHIFT == c1_IN_DOWN_END) {

      } else {

        chartInstance->c1_is_GEARSHIFT = c1_IN_DOWN_END;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

          &chartInstance->c1_is_GEARSHIFT);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 4));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 5));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

          (chartInstance->c1_is_GEARSHIFT == 6));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 18);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 18U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_DOWN_END = 1U;

        sf_call_output_fcn_call(chartInstance->S, 10, "Gearshift_free", 0);

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 9U,

                   chartInstance->c1_sfEvent);

      c1_q0 = chartInstance->c1_ticksCounter;

      c1_q1 = 1;

      c1_covSaturation = false;

      if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

        c1_covSaturation = true;

        c1_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 17U, 91U, 1U);

      } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

        c1_covSaturation = true;

        c1_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 17U, 91U, 1U);

      } else {

        c1_qY = c1_q0 - c1_q1;

      }



      CV_SATURATION_EVAL(4, 9, 0, 0, c1_covSaturation);

      chartInstance->c1_ticksCounter = c1_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      switch (chartInstance->c1_is_DOWN_BRAKE) {

       case c1_IN_ChangeClutch:

        CV_STATE_EVAL(9, 0, c1_IN_ChangeClutch);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 10U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 10U, chartInstance->c1_sfEvent);

        break;



       case c1_b_IN_Default:

        CV_STATE_EVAL(9, 0, c1_b_IN_Default);

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 11U,

                     chartInstance->c1_sfEvent);

        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 11U, chartInstance->c1_sfEvent);

        break;



       default:

        CV_STATE_EVAL(9, 0, 0);



        /* Unreachable state, for coverage only */

        chartInstance->c1_is_DOWN_BRAKE = c1_IN_NO_ACTIVE_CHILD;

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

          (chartInstance->c1_is_DOWN_BRAKE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

          (chartInstance->c1_is_DOWN_BRAKE == 2));

        _SFD_CS_CALL(STATE_INACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

        break;

      }

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 9U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_GEARSHIFT != c1_IN_DOWNSHIFTING) {

    } else {

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 8U, chartInstance->c1_sfEvent);

    }

    break;



   case c1_IN_DOWN_PUSH:

    CV_STATE_EVAL(8, 0, c1_IN_DOWN_PUSH);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 10U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(10U, (int32_T)_SFD_CCP_CALL(5U, 10U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 10U, 0, (real_T)

      chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter

      == 1) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_DOWN_PUSH = 0U;

      chartInstance->c1_is_DOWNSHIFTING = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 12U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_REBOUND) {

      } else {

        chartInstance->c1_is_DOWNSHIFTING = c1_IN_DOWN_REBOUND;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

          &chartInstance->c1_is_DOWNSHIFTING);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 4));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 15);

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 5);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 13U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_DOWN_REBOUND = 1U;

        chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

          &chartInstance->c1_ticksCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

        sf_call_output_fcn_call(chartInstance->S, 6, "Gearshift_rebound", 0);

        sf_call_output_fcn_call(chartInstance->S, 3, "Efi_unsetCut", 0);

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 12U,

                   chartInstance->c1_sfEvent);

      c1_b_q0 = chartInstance->c1_ticksCounter;

      c1_b_q1 = 1;

      c1_b_covSaturation = false;

      if ((c1_b_q1 < 0) && (c1_b_q0 > c1_b_q1 + MAX_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 15U, 119U, 1U);

      } else if ((c1_b_q1 > 0) && (c1_b_q0 < c1_b_q1 + MIN_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 15U, 119U, 1U);

      } else {

        c1_b_qY = c1_b_q0 - c1_b_q1;

      }



      CV_SATURATION_EVAL(4, 12, 0, 0, c1_b_covSaturation);

      chartInstance->c1_ticksCounter = c1_b_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 12U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 8U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_DOWN_REBOUND:

    CV_STATE_EVAL(8, 0, c1_IN_DOWN_REBOUND);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 11U,

                 chartInstance->c1_sfEvent);

    c1_d_out = (CV_TRANSITION_EVAL(11U, (int32_T)_SFD_CCP_CALL(5U, 11U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 11U, 0, (real_T)

      chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter

      == 1) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_d_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 11U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_DOWN_REBOUND = 0U;

      chartInstance->c1_is_DOWNSHIFTING = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 4));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 13U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_BRAKE) {

      } else {

        chartInstance->c1_is_DOWNSHIFTING = c1_IN_DOWN_BRAKE;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

          &chartInstance->c1_is_DOWNSHIFTING);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 3));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

          (chartInstance->c1_is_DOWNSHIFTING == 4));

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 9U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_DOWN_BRAKE = 1U;

        chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

          &chartInstance->c1_ticksCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      }



      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 73U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 72U,

                   chartInstance->c1_sfEvent);

      c1_e_out = (CV_TRANSITION_EVAL(72U, (int32_T)_SFD_CCP_CALL(5U, 72U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 72U, 0, (real_T)

        *chartInstance->c1_clutchCurrVal, 81.0, 0, 2U,

        *chartInstance->c1_clutchCurrVal < 81) != 0U, chartInstance->c1_sfEvent))

                  != 0);

      if (c1_e_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 72U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_DOWN_BRAKE == c1_IN_ChangeClutch) {

        } else {

          chartInstance->c1_is_DOWN_BRAKE = c1_IN_ChangeClutch;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 43, 17U, (void *)

            &chartInstance->c1_is_DOWN_BRAKE);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

            (chartInstance->c1_is_DOWN_BRAKE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

            (chartInstance->c1_is_DOWN_BRAKE == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 16);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 6);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 43, 17U, 1);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

          chartInstance->c1_b_tp_ChangeClutch = 1U;

          c1_Clutch_setValue(chartInstance, 0U);

          sf_call_output_fcn_call(chartInstance->S, 9, "Gearshift_brake", 0);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 74U, chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_DOWN_BRAKE == c1_b_IN_Default) {

        } else {

          chartInstance->c1_is_DOWN_BRAKE = c1_b_IN_Default;

          c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 43, 17U, (void *)

            &chartInstance->c1_is_DOWN_BRAKE);

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

            (chartInstance->c1_is_DOWN_BRAKE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

            (chartInstance->c1_is_DOWN_BRAKE == 2));

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 17);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 7);

          c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 43, 17U, 2);

          _SFD_CS_CALL(STATE_ACTIVE_TAG, 11U, chartInstance->c1_sfEvent);

          chartInstance->c1_e_tp_Default = 1U;

          sf_call_output_fcn_call(chartInstance->S, 9, "Gearshift_brake", 0);

        }

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 13U,

                   chartInstance->c1_sfEvent);

      c1_c_q0 = chartInstance->c1_ticksCounter;

      c1_c_q1 = 1;

      c1_c_covSaturation = false;

      if ((c1_c_q1 < 0) && (c1_c_q0 > c1_c_q1 + MAX_int32_T)) {

        c1_c_covSaturation = true;

        c1_c_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 16U, 141U, 1U);

      } else if ((c1_c_q1 > 0) && (c1_c_q0 < c1_c_q1 + MIN_int32_T)) {

        c1_c_covSaturation = true;

        c1_c_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 16U, 141U, 1U);

      } else {

        c1_c_qY = c1_c_q0 - c1_c_q1;

      }



      CV_SATURATION_EVAL(4, 13, 0, 0, c1_c_covSaturation);

      chartInstance->c1_ticksCounter = c1_c_qY;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 13U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 8U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_DOWN_START:

    CV_STATE_EVAL(8, 0, c1_IN_DOWN_START);

    c1_DOWN_START(chartInstance);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 8U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(8, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_DOWNSHIFTING = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 4));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 9U, chartInstance->c1_sfEvent);

    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 8U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_DOWN_START(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_covSaturation;

  int32_T c1_qY;

  boolean_T c1_c_out;

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 9U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(9U, (int32_T)_SFD_CCP_CALL(5U, 9U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 9U, 0, (real_T)

    chartInstance->c1_ticksCounter, 1.0, 0, 0U, chartInstance->c1_ticksCounter ==

    1) != 0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 9U, chartInstance->c1_sfEvent);

    c1_exit_internal_DOWN_START(chartInstance);

    chartInstance->c1_tp_DOWN_START = 0U;

    chartInstance->c1_is_DOWNSHIFTING = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 3));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

      (chartInstance->c1_is_DOWNSHIFTING == 4));

    c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 48, 14U, 0);

    c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 48, 14U, (void *)

      &chartInstance->c1_is_DOWN_START);

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 14U, chartInstance->c1_sfEvent);

    if (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_PUSH) {

    } else {

      chartInstance->c1_is_DOWNSHIFTING = c1_IN_DOWN_PUSH;

      c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

        &chartInstance->c1_is_DOWNSHIFTING);

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 3));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

        (chartInstance->c1_is_DOWNSHIFTING == 4));

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 41, 1U, 14);

      c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 42, 697U, 4);

      _SFD_CS_CALL(STATE_ACTIVE_TAG, 12U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_DOWN_PUSH = 1U;

      chartInstance->c1_ticksCounter = c1_Gearshift_getTime(chartInstance);

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

        &chartInstance->c1_ticksCounter);

      _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

      sf_call_output_fcn_call(chartInstance->S, 8, "Gearshift_down_push", 0);

    }



    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 205U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 206U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(206U, (int32_T)_SFD_CCP_CALL(5U, 206U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 206U, 0, (real_T)

      *chartInstance->c1_currTps, 20.0, 0, 5U, *chartInstance->c1_currTps >= 20)

      != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 206U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 207U, chartInstance->c1_sfEvent);

      sf_call_output_fcn_call(chartInstance->S, 2, "Efi_setCut", 0);

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 208U, chartInstance->c1_sfEvent);

    }

  } else {

    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 14U, chartInstance->c1_sfEvent);

    c1_q0 = chartInstance->c1_ticksCounter;

    c1_q1 = 1;

    c1_covSaturation = false;

    if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MAX_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 14U, 92U, 1U);

    } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MIN_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 14U, 92U, 1U);

    } else {

      c1_qY = c1_q0 - c1_q1;

    }



    CV_SATURATION_EVAL(4, 14, 0, 0, c1_covSaturation);

    chartInstance->c1_ticksCounter = c1_qY;

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

      &chartInstance->c1_ticksCounter);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_ticksCounter, 16U);

    switch (chartInstance->c1_is_DOWN_START) {

     case c1_IN_ChangeClutch:

      CV_STATE_EVAL(14, 0, c1_IN_ChangeClutch);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 15U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 15U, chartInstance->c1_sfEvent);

      break;



     case c1_b_IN_Default:

      CV_STATE_EVAL(14, 0, c1_b_IN_Default);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 16U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 16U, chartInstance->c1_sfEvent);

      break;



     case c1_b_IN_SettingNeutral:

      CV_STATE_EVAL(14, 0, c1_b_IN_SettingNeutral);

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 17U,

                   chartInstance->c1_sfEvent);

      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 17U, chartInstance->c1_sfEvent);

      break;



     default:

      CV_STATE_EVAL(14, 0, 0);



      /* Unreachable state, for coverage only */

      chartInstance->c1_is_DOWN_START = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

        (chartInstance->c1_is_DOWN_START == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

        (chartInstance->c1_is_DOWN_START == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

        (chartInstance->c1_is_DOWN_START == 3));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

      break;

    }

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 14U, chartInstance->c1_sfEvent);

}



static void c1_exit_internal_DOWN_START(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_DOWN_START) {

   case c1_IN_ChangeClutch:

    CV_STATE_EVAL(14, 1, c1_IN_ChangeClutch);

    chartInstance->c1_tp_ChangeClutch = 0U;

    chartInstance->c1_is_DOWN_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 3));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_Default:

    CV_STATE_EVAL(14, 1, c1_b_IN_Default);

    chartInstance->c1_d_tp_Default = 0U;

    chartInstance->c1_is_DOWN_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 3));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 16U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_SettingNeutral:

    CV_STATE_EVAL(14, 1, c1_b_IN_SettingNeutral);

    chartInstance->c1_c_tp_SettingNeutral = 0U;

    chartInstance->c1_is_DOWN_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 3));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 17U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(14, 1, 0);

    chartInstance->c1_is_DOWN_START = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

      (chartInstance->c1_is_DOWN_START == 3));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 15U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_exit_internal_DOWN_BRAKE(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  switch (chartInstance->c1_is_DOWN_BRAKE) {

   case c1_IN_ChangeClutch:

    CV_STATE_EVAL(9, 1, c1_IN_ChangeClutch);

    chartInstance->c1_b_tp_ChangeClutch = 0U;

    chartInstance->c1_is_DOWN_BRAKE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

      (chartInstance->c1_is_DOWN_BRAKE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

      (chartInstance->c1_is_DOWN_BRAKE == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_Default:

    CV_STATE_EVAL(9, 1, c1_b_IN_Default);

    chartInstance->c1_e_tp_Default = 0U;

    chartInstance->c1_is_DOWN_BRAKE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

      (chartInstance->c1_is_DOWN_BRAKE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

      (chartInstance->c1_is_DOWN_BRAKE == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 11U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(9, 1, 0);

    chartInstance->c1_is_DOWN_BRAKE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

      (chartInstance->c1_is_DOWN_BRAKE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

      (chartInstance->c1_is_DOWN_BRAKE == 2));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 10U, chartInstance->c1_sfEvent);

    break;

  }

}



static void c1_START_ENGINE(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  int32_T c1_i64;

  boolean_T c1_f_out;

  boolean_T c1_covSaturation;

  boolean_T guard1 = false;

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 87U, chartInstance->c1_sfEvent);

  switch (chartInstance->c1_is_START_ENGINE) {

   case c1_c_IN_START:

    CV_STATE_EVAL(87, 0, c1_c_IN_START);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 94U,

                 chartInstance->c1_sfEvent);

    c1_b_out = (CV_TRANSITION_EVAL(94U, (int32_T)_SFD_CCP_CALL(5U, 94U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 94U, 0, (real_T)

      chartInstance->c1_startCounter, 0.0, 0, 3U, chartInstance->c1_startCounter

      <= 0) != 0U, chartInstance->c1_sfEvent)) != 0);

    if (c1_b_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 94U, chartInstance->c1_sfEvent);

      chartInstance->c1_d_tp_START = 0U;

      chartInstance->c1_is_START_ENGINE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 3));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_START_ENGINE == c1_IN_STOP) {

      } else {

        chartInstance->c1_is_START_ENGINE = c1_IN_STOP;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

          &chartInstance->c1_is_START_ENGINE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 3));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 67, 479U, 3);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 89U, chartInstance->c1_sfEvent);

        chartInstance->c1_tp_STOP = 1U;

        sf_call_output_fcn_call(chartInstance->S, 12, "EngineControl_stop", 0);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 146U,

                   chartInstance->c1_sfEvent);

      c1_e_out = (CV_TRANSITION_EVAL(146U, (int32_T)_SFD_CCP_CALL(5U, 146U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 146U, 0, (real_T)

        *chartInstance->c1_startEngCom, (real_T)chartInstance->c1_lastCom, 0, 1U,

        *chartInstance->c1_startEngCom != chartInstance->c1_lastCom) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      guard1 = false;

      if (c1_e_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 146U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 93U,

                     chartInstance->c1_sfEvent);

        c1_f_out = (CV_TRANSITION_EVAL(93U, (int32_T)_SFD_CCP_CALL(5U, 93U, 0,

          (boolean_T)CV_RELATIONAL_EVAL(5U, 93U, 1, (real_T)

          *chartInstance->c1_startEngCom, (real_T)chartInstance->c1_lastCom, 0,

          1U, *chartInstance->c1_startEngCom != chartInstance->c1_lastCom) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_f_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 93U, chartInstance->c1_sfEvent);

          chartInstance->c1_d_tp_START = 0U;

          chartInstance->c1_is_START_ENGINE = c1_IN_NO_ACTIVE_CHILD;

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

            (chartInstance->c1_is_START_ENGINE == 1));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

            (chartInstance->c1_is_START_ENGINE == 2));

          c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

            (chartInstance->c1_is_START_ENGINE == 3));

          _SFD_CS_CALL(STATE_INACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_START_ENGINE == c1_c_IN_START) {

          } else {

            chartInstance->c1_is_START_ENGINE = c1_c_IN_START;

            c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

              &chartInstance->c1_is_START_ENGINE);

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

              (chartInstance->c1_is_START_ENGINE == 1));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

              (chartInstance->c1_is_START_ENGINE == 2));

            c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

              (chartInstance->c1_is_START_ENGINE == 3));

            c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 67, 479U, 2);

            _SFD_CS_CALL(STATE_ACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

            chartInstance->c1_d_tp_START = 1U;

            sf_call_output_fcn_call(chartInstance->S, 11, "EngineControl_start",

              0);

            chartInstance->c1_lastCom = *chartInstance->c1_startEngCom;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 85, 484U, (void *)

              &chartInstance->c1_lastCom);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastCom, 18U);

            chartInstance->c1_startCounter = 100U;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 86, 488U, (void *)

              &chartInstance->c1_startCounter);

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_startCounter, 19U);

          }

        } else {

          guard1 = true;

        }

      } else {

        guard1 = true;

      }



      if (guard1) {

        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 88U,

                     chartInstance->c1_sfEvent);

        c1_i64 = c1__s32_minus__(chartInstance, (int32_T)

          chartInstance->c1_startCounter, 1, 482U, 120, 1);

        c1_covSaturation = false;

        if (c1_i64 < 0) {

          c1_covSaturation = true;

          c1_i64 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 482U, 120U, 1U);

        } else {

          if (c1_i64 > 255) {

            c1_i64 = 255;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 482U, 120U, 1U);

          }



          CV_SATURATION_EVAL(4, 88, 0, 0, c1_covSaturation);

        }



        chartInstance->c1_startCounter = (uint8_T)c1_i64;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 86, 488U, (void *)

          &chartInstance->c1_startCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_startCounter, 19U);

      }

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 88U, chartInstance->c1_sfEvent);

    break;



   case c1_IN_STOP:

    CV_STATE_EVAL(87, 0, c1_IN_STOP);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 97U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 93U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(93U, (int32_T)_SFD_CCP_CALL(5U, 93U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 93U, 2, (real_T)

      *chartInstance->c1_startEngCom, (real_T)chartInstance->c1_lastCom, 0, 1U, *

      chartInstance->c1_startEngCom != chartInstance->c1_lastCom) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 93U, chartInstance->c1_sfEvent);

      chartInstance->c1_tp_STOP = 0U;

      chartInstance->c1_is_START_ENGINE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 3));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 89U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_START_ENGINE == c1_c_IN_START) {

      } else {

        chartInstance->c1_is_START_ENGINE = c1_c_IN_START;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

          &chartInstance->c1_is_START_ENGINE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 3));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 67, 479U, 2);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

        chartInstance->c1_d_tp_START = 1U;

        sf_call_output_fcn_call(chartInstance->S, 11, "EngineControl_start", 0);

        chartInstance->c1_lastCom = *chartInstance->c1_startEngCom;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 85, 484U, (void *)

          &chartInstance->c1_lastCom);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastCom, 18U);

        chartInstance->c1_startCounter = 100U;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 86, 488U, (void *)

          &chartInstance->c1_startCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_startCounter, 19U);

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 89U,

                   chartInstance->c1_sfEvent);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 89U, chartInstance->c1_sfEvent);

    break;



   case c1_b_IN_WAIT:

    CV_STATE_EVAL(87, 0, c1_b_IN_WAIT);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 96U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 93U,

                 chartInstance->c1_sfEvent);

    c1_d_out = (CV_TRANSITION_EVAL(93U, (int32_T)_SFD_CCP_CALL(5U, 93U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 93U, 0, (real_T)

      *chartInstance->c1_startEngCom, (real_T)chartInstance->c1_lastCom, 0, 1U, *

      chartInstance->c1_startEngCom != chartInstance->c1_lastCom) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_d_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 93U, chartInstance->c1_sfEvent);

      chartInstance->c1_b_tp_WAIT = 0U;

      chartInstance->c1_is_START_ENGINE = c1_IN_NO_ACTIVE_CHILD;

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 1));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 2));

      c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

        (chartInstance->c1_is_START_ENGINE == 3));

      _SFD_CS_CALL(STATE_INACTIVE_TAG, 90U, chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_START_ENGINE == c1_c_IN_START) {

      } else {

        chartInstance->c1_is_START_ENGINE = c1_c_IN_START;

        c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

          &chartInstance->c1_is_START_ENGINE);

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 1));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 2));

        c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

          (chartInstance->c1_is_START_ENGINE == 3));

        c1_c_sdiStreamingWrapperFcn(chartInstance, 2, 67, 479U, 2);

        _SFD_CS_CALL(STATE_ACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

        chartInstance->c1_d_tp_START = 1U;

        sf_call_output_fcn_call(chartInstance->S, 11, "EngineControl_start", 0);

        chartInstance->c1_lastCom = *chartInstance->c1_startEngCom;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 85, 484U, (void *)

          &chartInstance->c1_lastCom);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastCom, 18U);

        chartInstance->c1_startCounter = 100U;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 86, 488U, (void *)

          &chartInstance->c1_startCounter);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_startCounter, 19U);

      }

    } else {

      _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 90U,

                   chartInstance->c1_sfEvent);

    }



    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 90U, chartInstance->c1_sfEvent);

    break;



   default:

    CV_STATE_EVAL(87, 0, 0);



    /* Unreachable state, for coverage only */

    chartInstance->c1_is_START_ENGINE = c1_IN_NO_ACTIVE_CHILD;

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

      (chartInstance->c1_is_START_ENGINE == 1));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

      (chartInstance->c1_is_START_ENGINE == 2));

    c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

      (chartInstance->c1_is_START_ENGINE == 3));

    _SFD_CS_CALL(STATE_INACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

    break;

  }



  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 87U, chartInstance->c1_sfEvent);

}



static void init_script_number_translation(uint32_T c1_machineNumber, uint32_T

  c1_chartNumber, uint32_T c1_instanceNumber)

{

  (void)(c1_machineNumber);

  (void)(c1_chartNumber);

  (void)(c1_instanceNumber);

}



const mxArray *sf_c1_GCU_Model_genCode_get_eml_resolved_functions_info(void)

{

  const mxArray *c1_nameCaptureInfo = NULL;

  c1_nameCaptureInfo = NULL;

  sf_mex_assign(&c1_nameCaptureInfo, sf_mex_create("nameCaptureInfo", NULL, 0,

    0U, 1U, 0U, 2, 0, 1), false);

  return c1_nameCaptureInfo;

}



static void c1_checkClutch(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_temp;

  boolean_T c1_b_out;

  boolean_T c1_b_temp;

  boolean_T c1_c_temp;

  boolean_T c1_c_out;

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 77U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 77U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 126U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 127U, chartInstance->c1_sfEvent);

  c1_temp = _SFD_CCP_CALL(5U, 127U, 0, (boolean_T)CV_RELATIONAL_EVAL(5U, 127U, 0,

    (real_T)*chartInstance->c1_clutchTarget, (real_T)

    *chartInstance->c1_clutchCurrVal, 0, 1U, *chartInstance->c1_clutchTarget != *

    chartInstance->c1_clutchCurrVal) != 0U, chartInstance->c1_sfEvent);

  if (c1_temp) {

    c1_temp = _SFD_CCP_CALL(5U, 127U, 1, (*chartInstance->c1_antiStallFb ==

      ANTISTALL_OFF) != 0U, chartInstance->c1_sfEvent);

  }



  c1_b_out = (CV_TRANSITION_EVAL(127U, (int32_T)c1_temp) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 127U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 129U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 130U,

                 chartInstance->c1_sfEvent);

    c1_b_temp = !_SFD_CCP_CALL(5U, 130U, 0, (chartInstance->c1_is_GEARSHIFT ==

      c1_IN_DOWNSHIFTING) != 0U, chartInstance->c1_sfEvent);

    if (c1_b_temp) {

      c1_b_temp = !_SFD_CCP_CALL(5U, 130U, 1,

        (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) != 0U,

        chartInstance->c1_sfEvent);

    }



    c1_c_temp = c1_b_temp;

    if (!c1_c_temp) {

      c1_c_temp = _SFD_CCP_CALL(5U, 130U, 2, (chartInstance->c1_is_NEUTRAL_STATE

        == c1_IN_UNSET_NEUTRAL) != 0U, chartInstance->c1_sfEvent);

    }



    c1_c_out = (CV_TRANSITION_EVAL(130U, (int32_T)c1_c_temp) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 130U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 132U, chartInstance->c1_sfEvent);

      c1_Clutch_setValue(chartInstance, *chartInstance->c1_clutchTarget);

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 131U, chartInstance->c1_sfEvent);

    }

  } else {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 128U, chartInstance->c1_sfEvent);

  }



  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 77U, chartInstance->c1_sfEvent);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 77U, chartInstance->c1_sfEvent);

}



static void c1_checkShift(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  int32_T c1_previousEvent;

  boolean_T c1_e_out;

  int32_T c1_b_previousEvent;

  int32_T c1_c_previousEvent;

  boolean_T c1_f_out;

  int32_T c1_d_previousEvent;

  int32_T c1_e_previousEvent;

  int32_T c1_f_previousEvent;

  int32_T c1_g_previousEvent;

  int32_T c1_i65;

  int32_T c1_h_previousEvent;

  int32_T c1_i66;

  int32_T c1_i67;

  boolean_T c1_covSaturation;

  int32_T c1_i68;

  int32_T c1_i69;

  boolean_T c1_b_covSaturation;

  int32_T c1_i70;

  int32_T c1_i71;

  int32_T c1_i72;

  int32_T c1_i73;

  int32_T c1_i74;

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 78U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 78U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 122U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 123U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(123U, (int32_T)_SFD_CCP_CALL(5U, 123U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 123U, 0, (real_T)

    (*chartInstance->c1_shiftCom)[0], (real_T)chartInstance->c1_lastShiftCom, 0,

    1U, (*chartInstance->c1_shiftCom)[0] != chartInstance->c1_lastShiftCom) !=

    0U, chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 123U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 124U, chartInstance->c1_sfEvent);

    chartInstance->c1_lastShiftCom = (*chartInstance->c1_shiftCom)[0];

    c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 32, 681U, (void *)

      &chartInstance->c1_lastShiftCom);

    _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShiftCom, 3U);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 80U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(80U, (int32_T)_SFD_CCP_CALL(5U, 80U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 80U, 0, (real_T)

      (*chartInstance->c1_shiftCom)[1], (real_T)c1_const_GEAR_COMMAND_UP, 0, 0U,

      (*chartInstance->c1_shiftCom)[1] == c1_const_GEAR_COMMAND_UP) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 80U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 81U, chartInstance->c1_sfEvent);

      c1_previousEvent = chartInstance->c1_sfEvent;

      chartInstance->c1_sfEvent = c1_event_GearshiftUp;

      _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftUp,

                   chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_active_NEUTRAL_STATE == 0U) {

      } else {

        c1_NEUTRAL_STATE(chartInstance);

      }



      _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftUp,

                   chartInstance->c1_sfEvent);

      chartInstance->c1_sfEvent = c1_previousEvent;

      c1_c_previousEvent = chartInstance->c1_sfEvent;

      chartInstance->c1_sfEvent = c1_event_GearshiftUp;

      _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftUp,

                   chartInstance->c1_sfEvent);

      if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

      } else {

        c1_GEARSHIFT(chartInstance);

      }



      _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftUp,

                   chartInstance->c1_sfEvent);

      chartInstance->c1_sfEvent = c1_c_previousEvent;

      chartInstance->c1_lastTryShift[0] = c1_const_GEAR_COMMAND_UP;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

        &chartInstance->c1_lastTryShift);

      for (c1_i65 = 0; c1_i65 < 2; c1_i65++) {

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i65],

                              23U);

      }



      c1_i66 = c1__s32_add__(chartInstance, (int32_T)*chartInstance->c1_currGear,

        1, 453U, 130, 1);

      c1_covSaturation = false;

      if (c1_i66 < 0) {

        c1_covSaturation = true;

        c1_i66 = 0;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 453U, 130U, 1U);

      } else {

        if (c1_i66 > 65535) {

          c1_i66 = 65535;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 453U, 130U, 1U);

        }



        CV_SATURATION_EVAL(5, 81, 0, 0, c1_covSaturation);

      }



      chartInstance->c1_lastTryShift[1] = (uint16_T)c1_i66;

      c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

        &chartInstance->c1_lastTryShift);

      for (c1_i71 = 0; c1_i71 < 2; c1_i71++) {

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i71],

                              23U);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 82U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 83U,

                   chartInstance->c1_sfEvent);

      c1_d_out = (CV_TRANSITION_EVAL(83U, (int32_T)_SFD_CCP_CALL(5U, 83U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 83U, 0, (real_T)

        (*chartInstance->c1_shiftCom)[1], (real_T)c1_const_GEAR_COMMAND_DOWN, 0,

        0U, (*chartInstance->c1_shiftCom)[1] == c1_const_GEAR_COMMAND_DOWN) !=

        0U, chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 83U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 84U, chartInstance->c1_sfEvent);

        c1_b_previousEvent = chartInstance->c1_sfEvent;

        chartInstance->c1_sfEvent = c1_event_GearshiftDown;

        _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftDown,

                     chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_active_NEUTRAL_STATE == 0U) {

        } else {

          c1_NEUTRAL_STATE(chartInstance);

        }



        _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftDown,

                     chartInstance->c1_sfEvent);

        chartInstance->c1_sfEvent = c1_b_previousEvent;

        c1_e_previousEvent = chartInstance->c1_sfEvent;

        chartInstance->c1_sfEvent = c1_event_GearshiftDown;

        _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftDown,

                     chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

        } else {

          c1_GEARSHIFT(chartInstance);

        }



        _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftDown,

                     chartInstance->c1_sfEvent);

        chartInstance->c1_sfEvent = c1_e_previousEvent;

        chartInstance->c1_lastTryShift[0] = c1_const_GEAR_COMMAND_DOWN;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

          &chartInstance->c1_lastTryShift);

        for (c1_i67 = 0; c1_i67 < 2; c1_i67++) {

          _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i67],

                                23U);

        }



        c1_i68 = c1__s32_minus__(chartInstance, (int32_T)

          *chartInstance->c1_currGear, 1, 459U, 136, 1);

        c1_b_covSaturation = false;

        if (c1_i68 < 0) {

          c1_b_covSaturation = true;

          c1_i68 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 459U, 136U, 1U);

        } else {

          if (c1_i68 > 65535) {

            c1_i68 = 65535;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 459U, 136U, 1U);

          }



          CV_SATURATION_EVAL(5, 84, 0, 0, c1_b_covSaturation);

        }



        chartInstance->c1_lastTryShift[1] = (uint16_T)c1_i68;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

          &chartInstance->c1_lastTryShift);

        for (c1_i73 = 0; c1_i73 < 2; c1_i73++) {

          _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i73],

                                23U);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 85U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 86U,

                     chartInstance->c1_sfEvent);

        c1_e_out = (CV_TRANSITION_EVAL(86U, (int32_T)_SFD_CCP_CALL(5U, 86U, 0,

          (boolean_T)CV_RELATIONAL_EVAL(5U, 86U, 0, (real_T)

          (*chartInstance->c1_shiftCom)[1], (real_T)

          c1_const_GEAR_COMMAND_NEUTRAL_UP, 0, 0U, (*chartInstance->c1_shiftCom)

          [1] == c1_const_GEAR_COMMAND_NEUTRAL_UP) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_e_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 86U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 87U, chartInstance->c1_sfEvent);

          c1_d_previousEvent = chartInstance->c1_sfEvent;

          chartInstance->c1_sfEvent = c1_event_GearshiftSetNeutral;

          _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftSetNeutral,

                       chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_active_NEUTRAL_STATE == 0U) {

          } else {

            c1_NEUTRAL_STATE(chartInstance);

          }



          _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftSetNeutral,

                       chartInstance->c1_sfEvent);

          chartInstance->c1_sfEvent = c1_d_previousEvent;

          c1_g_previousEvent = chartInstance->c1_sfEvent;

          chartInstance->c1_sfEvent = c1_event_GearshiftUp;

          _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftUp,

                       chartInstance->c1_sfEvent);

          if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

          } else {

            c1_GEARSHIFT(chartInstance);

          }



          _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftUp,

                       chartInstance->c1_sfEvent);

          chartInstance->c1_sfEvent = c1_g_previousEvent;

          chartInstance->c1_lastTryShift[0] = c1_const_GEAR_COMMAND_NEUTRAL_UP;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

            &chartInstance->c1_lastTryShift);

          for (c1_i69 = 0; c1_i69 < 2; c1_i69++) {

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i69],

                                  23U);

          }



          chartInstance->c1_lastTryShift[1] = 0U;

          c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

            &chartInstance->c1_lastTryShift);

          for (c1_i72 = 0; c1_i72 < 2; c1_i72++) {

            _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastTryShift[c1_i72],

                                  23U);

          }

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 88U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 89U,

                       chartInstance->c1_sfEvent);

          c1_f_out = (CV_TRANSITION_EVAL(89U, (int32_T)_SFD_CCP_CALL(5U, 89U, 0,

            (boolean_T)CV_RELATIONAL_EVAL(5U, 89U, 0, (real_T)

            (*chartInstance->c1_shiftCom)[1], (real_T)

            c1_const_GEAR_COMMAND_NEUTRAL_DOWN, 0, 0U,

            (*chartInstance->c1_shiftCom)[1] ==

            c1_const_GEAR_COMMAND_NEUTRAL_DOWN) != 0U, chartInstance->c1_sfEvent))

                      != 0);

          if (c1_f_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 89U, chartInstance->c1_sfEvent);

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 90U, chartInstance->c1_sfEvent);

            c1_f_previousEvent = chartInstance->c1_sfEvent;

            chartInstance->c1_sfEvent = c1_event_GearshiftSetNeutral;

            _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,

                         c1_event_GearshiftSetNeutral, chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_active_NEUTRAL_STATE == 0U) {

            } else {

              c1_NEUTRAL_STATE(chartInstance);

            }



            _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftSetNeutral,

                         chartInstance->c1_sfEvent);

            chartInstance->c1_sfEvent = c1_f_previousEvent;

            c1_h_previousEvent = chartInstance->c1_sfEvent;

            chartInstance->c1_sfEvent = c1_event_GearshiftDown;

            _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftDown,

                         chartInstance->c1_sfEvent);

            if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

            } else {

              c1_GEARSHIFT(chartInstance);

            }



            _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftDown,

                         chartInstance->c1_sfEvent);

            chartInstance->c1_sfEvent = c1_h_previousEvent;

            chartInstance->c1_lastTryShift[0] =

              c1_const_GEAR_COMMAND_NEUTRAL_DOWN;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

              &chartInstance->c1_lastTryShift);

            for (c1_i70 = 0; c1_i70 < 2; c1_i70++) {

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->

                                    c1_lastTryShift[c1_i70], 23U);

            }



            chartInstance->c1_lastTryShift[1] = 0U;

            c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

              &chartInstance->c1_lastTryShift);

            for (c1_i74 = 0; c1_i74 < 2; c1_i74++) {

              _SFD_DATA_RANGE_CHECK((real_T)chartInstance->

                                    c1_lastTryShift[c1_i74], 23U);

            }

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 91U, chartInstance->c1_sfEvent);

          }

        }

      }

    }

  } else {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 125U, chartInstance->c1_sfEvent);

  }



  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 78U, chartInstance->c1_sfEvent);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 78U, chartInstance->c1_sfEvent);

}



static void c1_aacCheckShift(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_covSaturation;

  int32_T c1_qY;

  int32_T c1_i75;

  boolean_T c1_c_out;

  int32_T c1_b_q0;

  int32_T c1_b_q1;

  boolean_T c1_b_covSaturation;

  int32_T c1_b_qY;

  int32_T c1_i76;

  boolean_T c1_d_out;

  int32_T c1_previousEvent;

  int32_T c1_i77;

  boolean_T c1_c_covSaturation;

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 44U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 44U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 113U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 133U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(133U, (int32_T)_SFD_CCP_CALL(5U, 133U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 133U, 0, (real_T)

    chartInstance->c1_lastShift, (real_T)*chartInstance->c1_currGear, 0, 0U,

    chartInstance->c1_lastShift == *chartInstance->c1_currGear) != 0U,

    chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 133U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 134U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 114U,

                 chartInstance->c1_sfEvent);

    c1_q0 = c1__u8_s32_(chartInstance, (int32_T)acc_params_RPM_LIMIT_1_2, 605U,

                        12, 14) + *chartInstance->c1_currGear;

    c1_q1 = 1;

    c1_covSaturation = false;

    if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MAX_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 605U, 12U, 14U);

    } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MIN_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 605U, 12U, 14U);

    } else {

      c1_qY = c1_q0 - c1_q1;

    }



    CV_SATURATION_EVAL(5, 114, 0, 0, c1_covSaturation);

    c1_i75 = (*chartInstance->c1_acc_parameters)[sf_array_bounds_check

      (sfGlobalDebugInstanceStruct, chartInstance->S, 605U, 12, 14, 29U, c1_qY,

       0, 15)];

    c1_c_out = (CV_TRANSITION_EVAL(114U, (int32_T)_SFD_CCP_CALL(5U, 114U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 114U, 0, (real_T)

      *chartInstance->c1_currRpm, (real_T)c1_i75, 0, 5U,

      *chartInstance->c1_currRpm >= c1_i75) != 0U, chartInstance->c1_sfEvent))

                != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 114U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 116U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 117U,

                   chartInstance->c1_sfEvent);

      c1_b_q0 = c1__u8_s32_(chartInstance, (int32_T)acc_params_SPEED_LIMIT_1_2,

                            611U, 16, 14) + *chartInstance->c1_currGear;

      c1_b_q1 = 1;

      c1_b_covSaturation = false;

      if ((c1_b_q1 < 0) && (c1_b_q0 > c1_b_q1 + MAX_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 611U, 16U, 14U);

      } else if ((c1_b_q1 > 0) && (c1_b_q0 < c1_b_q1 + MIN_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 611U, 16U, 14U);

      } else {

        c1_b_qY = c1_b_q0 - c1_b_q1;

      }



      CV_SATURATION_EVAL(5, 117, 0, 0, c1_b_covSaturation);

      c1_i76 = (*chartInstance->c1_acc_parameters)[sf_array_bounds_check

        (sfGlobalDebugInstanceStruct, chartInstance->S, 611U, 16, 14, 29U,

         c1_b_qY, 0, 15)];

      c1_d_out = (CV_TRANSITION_EVAL(117U, (int32_T)_SFD_CCP_CALL(5U, 117U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 117U, 0, (real_T)

        *chartInstance->c1_currVhSpeed, (real_T)c1_i76, 0, 5U,

        *chartInstance->c1_currVhSpeed >= c1_i76) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 117U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 119U, chartInstance->c1_sfEvent);

        c1_previousEvent = chartInstance->c1_sfEvent;

        chartInstance->c1_sfEvent = c1_event_GearshiftUp;

        _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftUp,

                     chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

        } else {

          c1_GEARSHIFT(chartInstance);

        }



        _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftUp,

                     chartInstance->c1_sfEvent);

        chartInstance->c1_sfEvent = c1_previousEvent;

        c1_i77 = c1__s32_add__(chartInstance, (int32_T)

          chartInstance->c1_lastShift, 1, 615U, 53, 1);

        c1_c_covSaturation = false;

        if (c1_i77 < 0) {

          c1_c_covSaturation = true;

          c1_i77 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 615U, 53U, 1U);

        } else {

          if (c1_i77 > 255) {

            c1_i77 = 255;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 615U, 53U, 1U);

          }



          CV_SATURATION_EVAL(5, 119, 0, 0, c1_c_covSaturation);

        }



        chartInstance->c1_lastShift = (uint8_T)c1_i77;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

          &chartInstance->c1_lastShift);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 118U, chartInstance->c1_sfEvent);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 115U, chartInstance->c1_sfEvent);

    }

  } else {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 135U, chartInstance->c1_sfEvent);

  }



  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 44U, chartInstance->c1_sfEvent);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 44U, chartInstance->c1_sfEvent);

}



static int32_T c1_getAacParam(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, c1_acc_params c1_index)

{

  int32_T c1_param;

  int32_T c1_b_param;

  _SFD_SET_DATA_VALUE_PTR(85U, (void *)&c1_param);

  _SFD_SET_DATA_VALUE_PTR(79U, (void *)&c1_index);

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 46U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(2U, 0U);

  _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("index", &c1_index, c1_m_sf_marshallOut,

    c1_i_sf_marshallIn);

  _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("param", &c1_param, c1_sf_marshallOut,

    c1_sf_marshallIn);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 46U, chartInstance->c1_sfEvent);

  c1_param = 0;

  _SFD_DATA_RANGE_CHECK((real_T)c1_param, 85U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 108U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 109U, chartInstance->c1_sfEvent);

  c1_param = (*chartInstance->c1_acc_parameters)[sf_array_bounds_check

    (sfGlobalDebugInstanceStruct, chartInstance->S, 571U, 9, 14, 29U, (int32_T)

     c1_index, 0, 15)];

  _SFD_DATA_RANGE_CHECK((real_T)c1_param, 85U);

  c1_b_param = c1_param;

  sf_mex_printf("%s =\\n", "param");

  sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12, c1_b_param);

  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 46U, chartInstance->c1_sfEvent);

  _SFD_UNSET_DATA_VALUE_PTR(85U);

  _SFD_UNSET_DATA_VALUE_PTR(79U);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 46U, chartInstance->c1_sfEvent);

  return c1_param;

}



static void c1_autoXCheckShift(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_covSaturation;

  int32_T c1_qY;

  int32_T c1_i78;

  boolean_T c1_c_out;

  int32_T c1_b_q0;

  int32_T c1_b_q1;

  boolean_T c1_b_covSaturation;

  int32_T c1_b_qY;

  int32_T c1_i79;

  boolean_T c1_d_out;

  int32_T c1_previousEvent;

  int32_T c1_i80;

  boolean_T c1_c_covSaturation;

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 70U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 70U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 165U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 166U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(166U, (int32_T)_SFD_CCP_CALL(5U, 166U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 166U, 0, (real_T)

    chartInstance->c1_lastShift, (real_T)*chartInstance->c1_currGear, 0, 0U,

    chartInstance->c1_lastShift == *chartInstance->c1_currGear) != 0U,

    chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 166U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 168U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 169U,

                 chartInstance->c1_sfEvent);

    c1_q0 = c1__u8_s32_(chartInstance, (int32_T)autoX_params_AUTOX_RPM_LIMIT_1_2,

                        1019U, 12, 16) + *chartInstance->c1_currGear;

    c1_q1 = 1;

    c1_covSaturation = false;

    if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MAX_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1019U, 12U, 16U);

    } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MIN_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1019U, 12U, 16U);

    } else {

      c1_qY = c1_q0 - c1_q1;

    }



    CV_SATURATION_EVAL(5, 169, 0, 0, c1_covSaturation);

    c1_i78 = (*chartInstance->c1_autoX_parameters)[sf_array_bounds_check

      (sfGlobalDebugInstanceStruct, chartInstance->S, 1019U, 12, 16, 32U, c1_qY,

       0, 15)];

    c1_c_out = (CV_TRANSITION_EVAL(169U, (int32_T)_SFD_CCP_CALL(5U, 169U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 169U, 0, (real_T)

      *chartInstance->c1_currRpm, (real_T)c1_i78, 0, 5U,

      *chartInstance->c1_currRpm >= c1_i78) != 0U, chartInstance->c1_sfEvent))

                != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 169U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 171U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 172U,

                   chartInstance->c1_sfEvent);

      c1_b_q0 = c1__u8_s32_(chartInstance, (int32_T)

                            autoX_params_AUTOX_SPEED_LIMIT_1_2, 1022U, 16, 16) +

        *chartInstance->c1_currGear;

      c1_b_q1 = 1;

      c1_b_covSaturation = false;

      if ((c1_b_q1 < 0) && (c1_b_q0 > c1_b_q1 + MAX_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1022U, 16U, 16U);

      } else if ((c1_b_q1 > 0) && (c1_b_q0 < c1_b_q1 + MIN_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1022U, 16U, 16U);

      } else {

        c1_b_qY = c1_b_q0 - c1_b_q1;

      }



      CV_SATURATION_EVAL(5, 172, 0, 0, c1_b_covSaturation);

      c1_i79 = (*chartInstance->c1_autoX_parameters)[sf_array_bounds_check

        (sfGlobalDebugInstanceStruct, chartInstance->S, 1022U, 16, 16, 32U,

         c1_b_qY, 0, 15)];

      c1_d_out = (CV_TRANSITION_EVAL(172U, (int32_T)_SFD_CCP_CALL(5U, 172U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 172U, 0, (real_T)

        *chartInstance->c1_currVhSpeed, (real_T)c1_i79, 0, 5U,

        *chartInstance->c1_currVhSpeed >= c1_i79) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 172U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 174U, chartInstance->c1_sfEvent);

        c1_previousEvent = chartInstance->c1_sfEvent;

        chartInstance->c1_sfEvent = c1_event_GearshiftUp;

        _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftUp,

                     chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

        } else {

          c1_GEARSHIFT(chartInstance);

        }



        _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftUp,

                     chartInstance->c1_sfEvent);

        chartInstance->c1_sfEvent = c1_previousEvent;

        c1_i80 = c1__s32_add__(chartInstance, (int32_T)

          chartInstance->c1_lastShift, 1, 1024U, 53, 1);

        c1_c_covSaturation = false;

        if (c1_i80 < 0) {

          c1_c_covSaturation = true;

          c1_i80 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1024U, 53U, 1U);

        } else {

          if (c1_i80 > 255) {

            c1_i80 = 255;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 1024U, 53U, 1U);

          }



          CV_SATURATION_EVAL(5, 174, 0, 0, c1_c_covSaturation);

        }



        chartInstance->c1_lastShift = (uint8_T)c1_i80;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

          &chartInstance->c1_lastShift);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 173U, chartInstance->c1_sfEvent);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 170U, chartInstance->c1_sfEvent);

    }

  } else {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 167U, chartInstance->c1_sfEvent);

  }



  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 70U, chartInstance->c1_sfEvent);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 70U, chartInstance->c1_sfEvent);

}



static int32_T c1_getAutoXParam(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, c1_autoX_params c1_index)

{

  int32_T c1_param;

  int32_T c1_b_param;

  _SFD_SET_DATA_VALUE_PTR(83U, (void *)&c1_param);

  _SFD_SET_DATA_VALUE_PTR(78U, (void *)&c1_index);

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 72U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(2U, 0U);

  _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("index", &c1_index, c1_n_sf_marshallOut,

    c1_j_sf_marshallIn);

  _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("param", &c1_param, c1_sf_marshallOut,

    c1_sf_marshallIn);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 72U, chartInstance->c1_sfEvent);

  c1_param = 0;

  _SFD_DATA_RANGE_CHECK((real_T)c1_param, 83U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 175U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 176U, chartInstance->c1_sfEvent);

  c1_param = (*chartInstance->c1_autoX_parameters)[sf_array_bounds_check

    (sfGlobalDebugInstanceStruct, chartInstance->S, 1037U, 9, 16, 32U, (int32_T)

     c1_index, 0, 15)];

  _SFD_DATA_RANGE_CHECK((real_T)c1_param, 83U);

  c1_b_param = c1_param;

  sf_mex_printf("%s =\\n", "param");

  sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12, c1_b_param);

  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 72U, chartInstance->c1_sfEvent);

  _SFD_UNSET_DATA_VALUE_PTR(83U);

  _SFD_UNSET_DATA_VALUE_PTR(78U);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 72U, chartInstance->c1_sfEvent);

  return c1_param;

}



static void c1_b_autoXCheckShift(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  boolean_T c1_b_out;

  int32_T c1_q0;

  int32_T c1_q1;

  boolean_T c1_covSaturation;

  int32_T c1_qY;

  int32_T c1_i81;

  boolean_T c1_c_out;

  int32_T c1_b_q0;

  int32_T c1_b_q1;

  boolean_T c1_b_covSaturation;

  int32_T c1_b_qY;

  int32_T c1_i82;

  boolean_T c1_d_out;

  int32_T c1_previousEvent;

  int32_T c1_i83;

  boolean_T c1_c_covSaturation;

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 57U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 57U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 220U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 221U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(221U, (int32_T)_SFD_CCP_CALL(5U, 221U, 0,

    (boolean_T)CV_RELATIONAL_EVAL(5U, 221U, 0, (real_T)

    chartInstance->c1_lastShift, (real_T)*chartInstance->c1_currGear, 0, 0U,

    chartInstance->c1_lastShift == *chartInstance->c1_currGear) != 0U,

    chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 221U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 223U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 224U,

                 chartInstance->c1_sfEvent);

    c1_q0 = c1__u8_s32_(chartInstance, (int32_T)autoX_params_AUTOX_RPM_LIMIT_1_2,

                        2211U, 12, 16) + *chartInstance->c1_currGear;

    c1_q1 = 1;

    c1_covSaturation = false;

    if ((c1_q1 < 0) && (c1_q0 > c1_q1 + MAX_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MAX_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2211U, 12U, 16U);

    } else if ((c1_q1 > 0) && (c1_q0 < c1_q1 + MIN_int32_T)) {

      c1_covSaturation = true;

      c1_qY = MIN_int32_T;

      _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2211U, 12U, 16U);

    } else {

      c1_qY = c1_q0 - c1_q1;

    }



    CV_SATURATION_EVAL(5, 224, 0, 0, c1_covSaturation);

    c1_i81 = (*chartInstance->c1_autoX_parameters)[sf_array_bounds_check

      (sfGlobalDebugInstanceStruct, chartInstance->S, 2211U, 12, 16, 32U, c1_qY,

       0, 15)];

    c1_c_out = (CV_TRANSITION_EVAL(224U, (int32_T)_SFD_CCP_CALL(5U, 224U, 0,

      (boolean_T)CV_RELATIONAL_EVAL(5U, 224U, 0, (real_T)

      *chartInstance->c1_currRpm, (real_T)c1_i81, 0, 5U,

      *chartInstance->c1_currRpm >= c1_i81) != 0U, chartInstance->c1_sfEvent))

                != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 224U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 226U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 227U,

                   chartInstance->c1_sfEvent);

      c1_b_q0 = c1__u8_s32_(chartInstance, (int32_T)

                            autoX_params_AUTOX_SPEED_LIMIT_1_2, 2214U, 16, 16) +

        *chartInstance->c1_currGear;

      c1_b_q1 = 1;

      c1_b_covSaturation = false;

      if ((c1_b_q1 < 0) && (c1_b_q0 > c1_b_q1 + MAX_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MAX_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2214U, 16U, 16U);

      } else if ((c1_b_q1 > 0) && (c1_b_q0 < c1_b_q1 + MIN_int32_T)) {

        c1_b_covSaturation = true;

        c1_b_qY = MIN_int32_T;

        _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2214U, 16U, 16U);

      } else {

        c1_b_qY = c1_b_q0 - c1_b_q1;

      }



      CV_SATURATION_EVAL(5, 227, 0, 0, c1_b_covSaturation);

      c1_i82 = (*chartInstance->c1_autoX_parameters)[sf_array_bounds_check

        (sfGlobalDebugInstanceStruct, chartInstance->S, 2214U, 16, 16, 32U,

         c1_b_qY, 0, 15)];

      c1_d_out = (CV_TRANSITION_EVAL(227U, (int32_T)_SFD_CCP_CALL(5U, 227U, 0,

        (boolean_T)CV_RELATIONAL_EVAL(5U, 227U, 0, (real_T)

        *chartInstance->c1_currVhSpeed, (real_T)c1_i82, 0, 5U,

        *chartInstance->c1_currVhSpeed >= c1_i82) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_d_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 227U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 229U, chartInstance->c1_sfEvent);

        c1_previousEvent = chartInstance->c1_sfEvent;

        chartInstance->c1_sfEvent = c1_event_GearshiftUp;

        _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG, c1_event_GearshiftUp,

                     chartInstance->c1_sfEvent);

        if (chartInstance->c1_is_active_GEARSHIFT == 0U) {

        } else {

          c1_GEARSHIFT(chartInstance);

        }



        _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG, c1_event_GearshiftUp,

                     chartInstance->c1_sfEvent);

        chartInstance->c1_sfEvent = c1_previousEvent;

        c1_i83 = c1__s32_add__(chartInstance, (int32_T)

          chartInstance->c1_lastShift, 1, 2216U, 53, 1);

        c1_c_covSaturation = false;

        if (c1_i83 < 0) {

          c1_c_covSaturation = true;

          c1_i83 = 0;

          _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2216U, 53U, 1U);

        } else {

          if (c1_i83 > 255) {

            c1_i83 = 255;

            _SFD_OVERFLOW_DETECTION(SFDB_SATURATE, 2216U, 53U, 1U);

          }



          CV_SATURATION_EVAL(5, 229, 0, 0, c1_c_covSaturation);

        }



        chartInstance->c1_lastShift = (uint8_T)c1_i83;

        c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

          &chartInstance->c1_lastShift);

        _SFD_DATA_RANGE_CHECK((real_T)chartInstance->c1_lastShift, 22U);

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 228U, chartInstance->c1_sfEvent);

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 225U, chartInstance->c1_sfEvent);

    }

  } else {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 222U, chartInstance->c1_sfEvent);

  }



  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 57U, chartInstance->c1_sfEvent);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 57U, chartInstance->c1_sfEvent);

}



static int32_T c1_Gearshift_getTime(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  int32_T c1_b_time;

  boolean_T c1_b_out;

  boolean_T c1_c_out;

  boolean_T c1_d_out;

  boolean_T c1_e_out;

  boolean_T c1_f_out;

  boolean_T c1_g_out;

  boolean_T c1_h_out;

  boolean_T c1_i_out;

  int32_T c1_c_time;

  boolean_T c1_j_out;

  boolean_T c1_k_out;

  boolean_T c1_l_out;

  int32_T c1_d_time;

  boolean_T c1_m_out;

  boolean_T c1_n_out;

  int32_T c1_e_time;

  boolean_T c1_o_out;

  boolean_T c1_p_out;

  int32_T c1_f_time;

  int32_T c1_g_time;

  int32_T c1_h_time;

  _SFD_SET_DATA_VALUE_PTR(84U, (void *)&c1_b_time);

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 19U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(1U, 0U);

  _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("time", &c1_b_time, c1_sf_marshallOut,

    c1_sf_marshallIn);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 19U, chartInstance->c1_sfEvent);

  c1_b_time = 0;

  _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 19U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 20U, chartInstance->c1_sfEvent);

  c1_b_out = (CV_TRANSITION_EVAL(20U, (int32_T)_SFD_CCP_CALL(5U, 20U, 0,

    (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_START) != 0U,

    chartInstance->c1_sfEvent)) != 0);

  if (c1_b_out) {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 20U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 34U,

                 chartInstance->c1_sfEvent);

    c1_d_out = (CV_TRANSITION_EVAL(34U, (int32_T)_SFD_CCP_CALL(5U, 34U, 0,

      (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_d_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 34U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 35U, chartInstance->c1_sfEvent);

      c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

        (sfGlobalDebugInstanceStruct, chartInstance->S, 276U, 14, 7, 30U,

         (int32_T)DEFAULT_NT_CLUTCH_DELAY, 0, 23)];

      _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 36U, chartInstance->c1_sfEvent);

      c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

        (sfGlobalDebugInstanceStruct, chartInstance->S, 323U, 14, 7, 30U,

         (int32_T)DELAY, 0, 23)];

      _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

    }

  } else {

    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 21U, chartInstance->c1_sfEvent);

    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 22U,

                 chartInstance->c1_sfEvent);

    c1_c_out = (CV_TRANSITION_EVAL(22U, (int32_T)_SFD_CCP_CALL(5U, 22U, 0,

      (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_PUSH) != 0U,

      chartInstance->c1_sfEvent)) != 0);

    if (c1_c_out) {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 22U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 48U,

                   chartInstance->c1_sfEvent);

      c1_f_out = (CV_TRANSITION_EVAL(48U, (int32_T)_SFD_CCP_CALL(5U, 48U, 0,

        (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_f_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 48U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 56U, chartInstance->c1_sfEvent);

        c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

          (sfGlobalDebugInstanceStruct, chartInstance->S, 364U, 14, 7, 30U,

           (int32_T)NT_CLUTCH_DELAY, 0, 23)];

        _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

        c1_c_time = c1_b_time;

        sf_mex_printf("%s =\\n", "time");

        sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12,

                          c1_c_time);

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 49U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 46U,

                     chartInstance->c1_sfEvent);

        c1_i_out = (CV_TRANSITION_EVAL(46U, (int32_T)_SFD_CCP_CALL(5U, 46U, 0,

          (boolean_T)CV_RELATIONAL_EVAL(5U, 46U, 0, (real_T)

          *chartInstance->c1_currGear, 1.0, 0, 0U, *chartInstance->c1_currGear ==

          1) != 0U, chartInstance->c1_sfEvent)) != 0);

        if (c1_i_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 46U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 57U, chartInstance->c1_sfEvent);

          c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

            (sfGlobalDebugInstanceStruct, chartInstance->S, 366U, 14, 7, 30U,

             (int32_T)UP_PUSH_1_2, 0, 23)];

          _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

          c1_d_time = c1_b_time;

          sf_mex_printf("%s =\\n", "time");

          sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12,

                            c1_d_time);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 52U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 51U,

                       chartInstance->c1_sfEvent);

          c1_l_out = (CV_TRANSITION_EVAL(51U, (int32_T)_SFD_CCP_CALL(5U, 51U, 0,

            (boolean_T)CV_RELATIONAL_EVAL(5U, 51U, 0, (real_T)

            *chartInstance->c1_currGear, 2.0, 0, 0U, *chartInstance->c1_currGear

            == 2) != 0U, chartInstance->c1_sfEvent)) != 0);

          if (c1_l_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 51U, chartInstance->c1_sfEvent);

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 58U, chartInstance->c1_sfEvent);

            c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

              (sfGlobalDebugInstanceStruct, chartInstance->S, 368U, 14, 7, 30U,

               (int32_T)UP_PUSH_2_3, 0, 23)];

            _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

            c1_e_time = c1_b_time;

            sf_mex_printf("%s =\\n", "time");

            sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12,

                              c1_e_time);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 50U, chartInstance->c1_sfEvent);

            _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 54U,

                         chartInstance->c1_sfEvent);

            c1_n_out = (CV_TRANSITION_EVAL(54U, (int32_T)_SFD_CCP_CALL(5U, 54U,

              0, (boolean_T)CV_RELATIONAL_EVAL(5U, 54U, 0, (real_T)

              *chartInstance->c1_currGear, 3.0, 0, 0U,

              *chartInstance->c1_currGear == 3) != 0U, chartInstance->c1_sfEvent))

                        != 0);

            if (c1_n_out) {

              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 54U, chartInstance->c1_sfEvent);

              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 59U, chartInstance->c1_sfEvent);

              c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

                (sfGlobalDebugInstanceStruct, chartInstance->S, 370U, 14, 7, 30U,

                 (int32_T)UP_PUSH_3_4, 0, 23)];

              _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

              c1_f_time = c1_b_time;

              sf_mex_printf("%s =\\n", "time");

              sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U, 12,

                                c1_f_time);

            } else {

              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 55U, chartInstance->c1_sfEvent);

              _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 47U,

                           chartInstance->c1_sfEvent);

              c1_p_out = (CV_TRANSITION_EVAL(47U, (int32_T)_SFD_CCP_CALL(5U, 47U,

                0, (boolean_T)CV_RELATIONAL_EVAL(5U, 47U, 0, (real_T)

                *chartInstance->c1_currGear, 4.0, 0, 0U,

                *chartInstance->c1_currGear == 4) != 0U,

                chartInstance->c1_sfEvent)) != 0);

              if (c1_p_out) {

                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 47U,

                             chartInstance->c1_sfEvent);

                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 60U,

                             chartInstance->c1_sfEvent);

                c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

                  (sfGlobalDebugInstanceStruct, chartInstance->S, 372U, 14, 7,

                   30U, (int32_T)UP_PUSH_4_5, 0, 23)];

                _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

                c1_h_time = c1_b_time;

                sf_mex_printf("%s =\\n", "time");

                sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U,

                                  12, c1_h_time);

              } else {

                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 53U,

                             chartInstance->c1_sfEvent);

                c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

                  (sfGlobalDebugInstanceStruct, chartInstance->S, 357U, 14, 7,

                   30U, (int32_T)UP_PUSH_2_3, 0, 23)];

                _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

                c1_g_time = c1_b_time;

                sf_mex_printf("%s =\\n", "time");

                sf_mex_call_debug(sfGlobalDebugInstanceStruct, "disp", 0U, 1U,

                                  12, c1_g_time);

              }

            }

          }

        }

      }

    } else {

      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 23U, chartInstance->c1_sfEvent);

      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 24U,

                   chartInstance->c1_sfEvent);

      c1_e_out = (CV_TRANSITION_EVAL(24U, (int32_T)_SFD_CCP_CALL(5U, 24U, 0,

        (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_REBOUND) != 0U,

        chartInstance->c1_sfEvent)) != 0);

      if (c1_e_out) {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 24U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 37U,

                     chartInstance->c1_sfEvent);

        c1_h_out = (CV_TRANSITION_EVAL(37U, (int32_T)_SFD_CCP_CALL(5U, 37U, 0,

          (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_h_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 37U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 39U, chartInstance->c1_sfEvent);

          c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

            (sfGlobalDebugInstanceStruct, chartInstance->S, 329U, 14, 7, 30U,

             (int32_T)NT_REBOUND_1_N, 0, 23)];

          _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 38U, chartInstance->c1_sfEvent);

          c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

            (sfGlobalDebugInstanceStruct, chartInstance->S, 328U, 14, 7, 30U,

             (int32_T)UP_REBOUND, 0, 23)];

          _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

        }

      } else {

        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 25U, chartInstance->c1_sfEvent);

        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 26U,

                     chartInstance->c1_sfEvent);

        c1_g_out = (CV_TRANSITION_EVAL(26U, (int32_T)_SFD_CCP_CALL(5U, 26U, 0,

          (chartInstance->c1_is_UPSHIFTING == c1_IN_UP_BRAKE) != 0U,

          chartInstance->c1_sfEvent)) != 0);

        if (c1_g_out) {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 26U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 40U,

                       chartInstance->c1_sfEvent);

          c1_k_out = (CV_TRANSITION_EVAL(40U, (int32_T)_SFD_CCP_CALL(5U, 40U, 0,

            (chartInstance->c1_is_NEUTRAL_STATE == c1_IN_SET_NEUTRAL) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_k_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 40U, chartInstance->c1_sfEvent);

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 42U, chartInstance->c1_sfEvent);

            c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

              (sfGlobalDebugInstanceStruct, chartInstance->S, 335U, 14, 7, 30U,

               (int32_T)NT_BRAKE_1_N, 0, 23)];

            _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 41U, chartInstance->c1_sfEvent);

            c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

              (sfGlobalDebugInstanceStruct, chartInstance->S, 334U, 14, 7, 30U,

               (int32_T)UP_BRAKE, 0, 23)];

            _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

          }

        } else {

          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 27U, chartInstance->c1_sfEvent);

          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 28U,

                       chartInstance->c1_sfEvent);

          c1_j_out = (CV_TRANSITION_EVAL(28U, (int32_T)_SFD_CCP_CALL(5U, 28U, 0,

            (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_START) != 0U,

            chartInstance->c1_sfEvent)) != 0);

          if (c1_j_out) {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 28U, chartInstance->c1_sfEvent);

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 43U, chartInstance->c1_sfEvent);

            c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

              (sfGlobalDebugInstanceStruct, chartInstance->S, 337U, 14, 7, 30U,

               (int32_T)CLUTCH, 0, 23)];

            _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

          } else {

            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 29U, chartInstance->c1_sfEvent);

            _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 30U,

                         chartInstance->c1_sfEvent);

            c1_m_out = (CV_TRANSITION_EVAL(30U, (int32_T)_SFD_CCP_CALL(5U, 30U,

              0, (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_PUSH) != 0U,

              chartInstance->c1_sfEvent)) != 0);

            if (c1_m_out) {

              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 30U, chartInstance->c1_sfEvent);

              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 44U, chartInstance->c1_sfEvent);

              c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

                (sfGlobalDebugInstanceStruct, chartInstance->S, 339U, 14, 7, 30U,

                 (int32_T)DN_PUSH, 0, 23)];

              _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

            } else {

              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 31U, chartInstance->c1_sfEvent);

              _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 32U,

                           chartInstance->c1_sfEvent);

              c1_o_out = (CV_TRANSITION_EVAL(32U, (int32_T)_SFD_CCP_CALL(5U, 32U,

                0, (chartInstance->c1_is_DOWNSHIFTING == c1_IN_DOWN_REBOUND) !=

                0U, chartInstance->c1_sfEvent)) != 0);

              if (c1_o_out) {

                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 32U,

                             chartInstance->c1_sfEvent);

                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 45U,

                             chartInstance->c1_sfEvent);

                c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

                  (sfGlobalDebugInstanceStruct, chartInstance->S, 341U, 14, 7,

                   30U, (int32_T)DN_REBOUND, 0, 23)];

                _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

              } else {

                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 33U,

                             chartInstance->c1_sfEvent);

                c1_b_time = (*chartInstance->c1_timings)[sf_array_bounds_check

                  (sfGlobalDebugInstanceStruct, chartInstance->S, 270U, 14, 7,

                   30U, (int32_T)DN_BRAKE, 0, 23)];

                _SFD_DATA_RANGE_CHECK((real_T)c1_b_time, 84U);

              }

            }

          }

        }

      }

    }

  }



  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 19U, chartInstance->c1_sfEvent);

  _SFD_UNSET_DATA_VALUE_PTR(84U);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 19U, chartInstance->c1_sfEvent);

  return c1_b_time;

}



static void c1_Clutch_setValue(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, uint8_T c1_setValue)

{

  _SFD_DATA_RANGE_CHECK((real_T)c1_setValue, 80U);

  _SFD_SET_DATA_VALUE_PTR(80U, (void *)&c1_setValue);

  _SFD_CS_CALL(FUNCTION_ACTIVE_TAG, 3U, chartInstance->c1_sfEvent);

  _SFD_SYMBOL_SCOPE_PUSH(1U, 0U);

  _SFD_SYMBOL_SCOPE_ADD_IMPORTABLE("setValue", &c1_setValue, c1_b_sf_marshallOut,

    c1_b_sf_marshallIn);

  _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 3U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 98U, chartInstance->c1_sfEvent);

  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 99U, chartInstance->c1_sfEvent);

  *chartInstance->c1_clutchCurrVal = c1_setValue;

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 0, 123U, (void *)

    chartInstance->c1_clutchCurrVal);

  _SFD_DATA_RANGE_CHECK_MIN_MAX((real_T)*chartInstance->c1_clutchCurrVal, 47U,

    0.0, 100.0, 506U, 1, 25);

  sf_call_output_fcn_call(chartInstance->S, 0, "Clutch_set", 0);

  _SFD_SYMBOL_SCOPE_POP();

  _SFD_CS_CALL(FUNCTION_INACTIVE_TAG, 3U, chartInstance->c1_sfEvent);

  _SFD_UNSET_DATA_VALUE_PTR(80U);

  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 3U, chartInstance->c1_sfEvent);

}



static const mxArray *c1_sf_marshallOut(void *chartInstanceVoid, void *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_u;

  const mxArray *c1_y = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(int32_T *)c1_inData;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", &c1_u, 6, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static int32_T c1_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_sfEvent, const char_T *c1_identifier)

{

  int32_T c1_y;

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_b_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_sfEvent),

    &c1_thisId);

  sf_mex_destroy(&c1_b_sfEvent);

  return c1_y;

}



static int32_T c1_b_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  int32_T c1_y;

  int32_T c1_i84;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_i84, 1, 6, 0U, 0, 0U, 0);

  c1_y = c1_i84;

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_sfEvent;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  int32_T c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_sfEvent = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_b_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_sfEvent),

    &c1_thisId);

  sf_mex_destroy(&c1_b_sfEvent);

  *(int32_T *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_b_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  uint8_T c1_u;

  const mxArray *c1_y = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(uint8_T *)c1_inData;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", &c1_u, 3, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static uint8_T c1_c_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_tp_MODES, const char_T *c1_identifier)

{

  uint8_T c1_y;

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_d_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_tp_MODES),

    &c1_thisId);

  sf_mex_destroy(&c1_b_tp_MODES);

  return c1_y;

}



static uint8_T c1_d_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  uint8_T c1_y;

  uint8_T c1_u26;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_u26, 1, 3, 0U, 0, 0U, 0);

  c1_y = c1_u26;

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_b_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_tp_MODES;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  uint8_T c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_tp_MODES = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_d_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_tp_MODES),

    &c1_thisId);

  sf_mex_destroy(&c1_b_tp_MODES);

  *(uint8_T *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_c_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_i85;

  const mxArray *c1_y = NULL;

  uint16_T c1_u[2];

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  for (c1_i85 = 0; c1_i85 < 2; c1_i85++) {

    c1_u[c1_i85] = (*(uint16_T (*)[2])c1_inData)[c1_i85];

  }



  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", c1_u, 5, 0U, 1U, 0U, 1, 2), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static void c1_e_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_lastModeCom, const char_T *c1_identifier,

  uint16_T c1_y[2])

{

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_f_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_lastModeCom), &c1_thisId,

                        c1_y);

  sf_mex_destroy(&c1_b_lastModeCom);

}



static void c1_f_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId,

  uint16_T c1_y[2])

{

  uint16_T c1_uv0[2];

  int32_T c1_i86;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), c1_uv0, 1, 5, 0U, 1, 0U, 1, 2);

  for (c1_i86 = 0; c1_i86 < 2; c1_i86++) {

    c1_y[c1_i86] = c1_uv0[c1_i86];

  }



  sf_mex_destroy(&c1_u);

}



static void c1_c_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_lastModeCom;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  uint16_T c1_y[2];

  int32_T c1_i87;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_lastModeCom = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_f_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_lastModeCom), &c1_thisId,

                        c1_y);

  sf_mex_destroy(&c1_b_lastModeCom);

  for (c1_i87 = 0; c1_i87 < 2; c1_i87++) {

    (*(uint16_T (*)[2])c1_outData)[c1_i87] = c1_y[c1_i87];

  }



  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_d_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_i88;

  const mxArray *c1_y = NULL;

  uint16_T c1_u[2];

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  for (c1_i88 = 0; c1_i88 < 2; c1_i88++) {

    c1_u[c1_i88] = (*(uint16_T (*)[2])c1_inData)[c1_i88];

  }



  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", c1_u, 5, 0U, 1U, 0U, 2, 1, 2), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static const mxArray *c1_e_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  uint16_T c1_u;

  const mxArray *c1_y = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(uint16_T *)c1_inData;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", &c1_u, 5, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static uint16_T c1_g_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_stateFb, const char_T *c1_identifier)

{

  uint16_T c1_y;

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_h_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_stateFb),

    &c1_thisId);

  sf_mex_destroy(&c1_b_stateFb);

  return c1_y;

}



static uint16_T c1_h_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  uint16_T c1_y;

  uint16_T c1_u27;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_u27, 1, 5, 0U, 0, 0U, 0);

  c1_y = c1_u27;

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_d_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_stateFb;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  uint16_T c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_stateFb = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_h_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_stateFb),

    &c1_thisId);

  sf_mex_destroy(&c1_b_stateFb);

  *(uint16_T *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_f_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_i89;

  const mxArray *c1_y = NULL;

  int32_T c1_u[16];

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  for (c1_i89 = 0; c1_i89 < 16; c1_i89++) {

    c1_u[c1_i89] = (*(int32_T (*)[16])c1_inData)[c1_i89];

  }



  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", c1_u, 6, 0U, 1U, 0U, 2, 1, 16), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static const mxArray *c1_g_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_i90;

  const mxArray *c1_y = NULL;

  int32_T c1_u[24];

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  for (c1_i90 = 0; c1_i90 < 24; c1_i90++) {

    c1_u[c1_i90] = (*(int32_T (*)[24])c1_inData)[c1_i90];

  }



  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", c1_u, 6, 0U, 1U, 0U, 2, 1, 24), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static const mxArray *c1_h_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_i91;

  const mxArray *c1_y = NULL;

  int32_T c1_u[8];

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  for (c1_i91 = 0; c1_i91 < 8; c1_i91++) {

    c1_u[c1_i91] = (*(int32_T (*)[8])c1_inData)[c1_i91];

  }



  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", c1_u, 6, 0U, 1U, 0U, 2, 1, 8), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static const mxArray *c1_i_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  int32_T c1_i92;

  const mxArray *c1_y = NULL;

  uint32_T c1_u[2];

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  for (c1_i92 = 0; c1_i92 < 2; c1_i92++) {

    c1_u[c1_i92] = (*(uint32_T (*)[2])c1_inData)[c1_i92];

  }



  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", c1_u, 7, 0U, 1U, 0U, 1, 2), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static const mxArray *c1_j_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  uint32_T c1_u;

  const mxArray *c1_y = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(uint32_T *)c1_inData;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", &c1_u, 7, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static uint32_T c1_i_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_pidCounter, const char_T *c1_identifier)

{

  uint32_T c1_y;

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_j_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_pidCounter),

    &c1_thisId);

  sf_mex_destroy(&c1_b_pidCounter);

  return c1_y;

}



static uint32_T c1_j_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  uint32_T c1_y;

  uint32_T c1_u28;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_u28, 1, 7, 0U, 0, 0U, 0);

  c1_y = c1_u28;

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_e_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_pidCounter;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  uint32_T c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_pidCounter = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_j_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_pidCounter),

    &c1_thisId);

  sf_mex_destroy(&c1_b_pidCounter);

  *(uint32_T *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_k_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  real_T c1_u;

  const mxArray *c1_y = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(real_T *)c1_inData;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", &c1_u, 0, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static void c1_k_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_lastTryShift, const char_T *c1_identifier,

  uint16_T c1_y[2])

{

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_l_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_lastTryShift), &c1_thisId,

                        c1_y);

  sf_mex_destroy(&c1_b_lastTryShift);

}



static void c1_l_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId,

  uint16_T c1_y[2])

{

  uint16_T c1_uv1[2];

  int32_T c1_i93;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), c1_uv1, 1, 5, 0U, 1, 0U, 2, 1, 2);

  for (c1_i93 = 0; c1_i93 < 2; c1_i93++) {

    c1_y[c1_i93] = c1_uv1[c1_i93];

  }



  sf_mex_destroy(&c1_u);

}



static void c1_f_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_lastTryShift;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  uint16_T c1_y[2];

  int32_T c1_i94;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_lastTryShift = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_l_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_lastTryShift), &c1_thisId,

                        c1_y);

  sf_mex_destroy(&c1_b_lastTryShift);

  for (c1_i94 = 0; c1_i94 < 2; c1_i94++) {

    (*(uint16_T (*)[2])c1_outData)[c1_i94] = c1_y[c1_i94];

  }



  sf_mex_destroy(&c1_mxArrayInData);

}



static real_T c1_m_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_aac_clutchValue, const char_T

  *c1_identifier)

{

  real_T c1_y;

  emlrtMsgIdentifier c1_thisId;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_n_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_aac_clutchValue),

    &c1_thisId);

  sf_mex_destroy(&c1_b_aac_clutchValue);

  return c1_y;

}



static real_T c1_n_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  real_T c1_y;

  real_T c1_d8;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_d8, 1, 0, 0U, 0, 0U, 0);

  c1_y = c1_d8;

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_g_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_aac_clutchValue;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  real_T c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_aac_clutchValue = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_n_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_aac_clutchValue),

    &c1_thisId);

  sf_mex_destroy(&c1_b_aac_clutchValue);

  *(real_T *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_l_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  boolean_T c1_u;

  const mxArray *c1_y = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(boolean_T *)c1_inData;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_create("y", &c1_u, 11, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static boolean_T c1_o_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  boolean_T c1_y;

  boolean_T c1_b0;

  (void)chartInstance;

  sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_b0, 1, 11, 0U, 0, 0U, 0);

  c1_y = c1_b0;

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_h_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_b_out;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  boolean_T c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_b_out = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_o_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_out), &c1_thisId);

  sf_mex_destroy(&c1_b_out);

  *(boolean_T *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_m_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  c1_acc_params c1_u;

  const mxArray *c1_y = NULL;

  int32_T c1_b_u;

  const mxArray *c1_b_y = NULL;

  const mxArray *c1_m0 = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(c1_acc_params *)c1_inData;

  c1_y = NULL;

  sf_mex_check_enum("acc_params", 13, c1_sv0, c1_iv0);

  c1_b_u = (int32_T)c1_u;

  c1_b_y = NULL;

  sf_mex_assign(&c1_b_y, sf_mex_create("y", &c1_b_u, 6, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_m0, c1_b_y, false);

  sf_mex_assign(&c1_y, sf_mex_create_enum("acc_params", c1_m0), false);

  sf_mex_destroy(&c1_m0);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static c1_acc_params c1_p_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct *

  chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  c1_acc_params c1_y;

  (void)chartInstance;

  sf_mex_check_enum("acc_params", 13, c1_sv0, c1_iv0);

  sf_mex_check_builtin(c1_parentId, c1_u, "acc_params", 0, 0U, NULL);

  c1_y = (c1_acc_params)sf_mex_get_enum_element(c1_u, 0);

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_i_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_index;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  c1_acc_params c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_index = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_p_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_index), &c1_thisId);

  sf_mex_destroy(&c1_index);

  *(c1_acc_params *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static const mxArray *c1_n_sf_marshallOut(void *chartInstanceVoid, void

  *c1_inData)

{

  const mxArray *c1_mxArrayOutData;

  c1_autoX_params c1_u;

  const mxArray *c1_y = NULL;

  int32_T c1_b_u;

  const mxArray *c1_b_y = NULL;

  const mxArray *c1_m1 = NULL;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_mxArrayOutData = NULL;

  c1_mxArrayOutData = NULL;

  c1_u = *(c1_autoX_params *)c1_inData;

  c1_y = NULL;

  sf_mex_check_enum("autoX_params", 13, c1_sv1, c1_iv0);

  c1_b_u = (int32_T)c1_u;

  c1_b_y = NULL;

  sf_mex_assign(&c1_b_y, sf_mex_create("y", &c1_b_u, 6, 0U, 0U, 0U, 0), false);

  sf_mex_assign(&c1_m1, c1_b_y, false);

  sf_mex_assign(&c1_y, sf_mex_create_enum("autoX_params", c1_m1), false);

  sf_mex_destroy(&c1_m1);

  sf_mex_assign(&c1_mxArrayOutData, c1_y, false);

  return c1_mxArrayOutData;

}



static c1_autoX_params c1_q_emlrt_marshallIn

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance, const mxArray *c1_u,

   const emlrtMsgIdentifier *c1_parentId)

{

  c1_autoX_params c1_y;

  (void)chartInstance;

  sf_mex_check_enum("autoX_params", 13, c1_sv1, c1_iv0);

  sf_mex_check_builtin(c1_parentId, c1_u, "autoX_params", 0, 0U, NULL);

  c1_y = (c1_autoX_params)sf_mex_get_enum_element(c1_u, 0);

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static void c1_j_sf_marshallIn(void *chartInstanceVoid, const mxArray

  *c1_mxArrayInData, const char_T *c1_varName, void *c1_outData)

{

  const mxArray *c1_index;

  const char_T *c1_identifier;

  emlrtMsgIdentifier c1_thisId;

  c1_autoX_params c1_y;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)chartInstanceVoid;

  c1_index = sf_mex_dup(c1_mxArrayInData);

  c1_identifier = c1_varName;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  c1_y = c1_q_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_index), &c1_thisId);

  sf_mex_destroy(&c1_index);

  *(c1_autoX_params *)c1_outData = c1_y;

  sf_mex_destroy(&c1_mxArrayInData);

}



static void c1_r_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u)

{

  uint16_T c1_uv2[2];

  int32_T c1_i95;

  uint16_T c1_uv3[2];

  int32_T c1_i96;

  *chartInstance->c1_antiStallEnable = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 0)), "antiStallEnable");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 14, 1073U, (void *)

    chartInstance->c1_antiStallEnable);

  *chartInstance->c1_clutchCurrVal = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 1)), "clutchCurrVal");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 0, 123U, (void *)

    chartInstance->c1_clutchCurrVal);

  c1_e_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c1_u, 2)),

                        "lastModeCom", c1_uv2);

  for (c1_i95 = 0; c1_i95 < 2; c1_i95++) {

    (*chartInstance->c1_lastModeCom)[c1_i95] = c1_uv2[c1_i95];

  }



  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 1, 834U, (void *)

    chartInstance->c1_lastModeCom);

  *chartInstance->c1_pidCounter = c1_i_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 3)), "pidCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 25, 1839U, (void *)

    chartInstance->c1_pidCounter);

  *chartInstance->c1_rpmAccTarget = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 4)), "rpmAccTarget");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 30, 2851U, (void *)

    chartInstance->c1_rpmAccTarget);

  *chartInstance->c1_stateFb = c1_g_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 5)), "stateFb");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 8, 833U, (void *)

    chartInstance->c1_stateFb);

  chartInstance->c1_aacCounter = c1_g_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 6)), "aacCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 44, 550U, (void *)

    &chartInstance->c1_aacCounter);

  chartInstance->c1_aac_clutchStep = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 7)), "aac_clutchStep");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 46, 563U, (void *)

    &chartInstance->c1_aac_clutchStep);

  chartInstance->c1_aac_clutchValue = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 8)), "aac_clutchValue");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 45, 561U, (void *)

    &chartInstance->c1_aac_clutchValue);

  chartInstance->c1_aac_dtRelease = c1_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 9)), "aac_dtRelease");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 47, 564U, (void *)

    &chartInstance->c1_aac_dtRelease);

  chartInstance->c1_autoXCounter = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 10)), "autoXCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 63, 958U, (void *)

    &chartInstance->c1_autoXCounter);

  chartInstance->c1_b_autoXCounter = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 11)), "autoXCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 70, 2170U, (void *)

    &chartInstance->c1_b_autoXCounter);

  chartInstance->c1_autoX_clutchStep = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 12)), "autoX_clutchStep");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 65, 960U, (void *)

    &chartInstance->c1_autoX_clutchStep);

  chartInstance->c1_b_autoX_clutchStep = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 13)), "autoX_clutchStep");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 72, 2172U, (void *)

    &chartInstance->c1_b_autoX_clutchStep);

  chartInstance->c1_autoX_clutchValue = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 14)), "autoX_clutchValue");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 64, 959U, (void *)

    &chartInstance->c1_autoX_clutchValue);

  chartInstance->c1_b_autoX_clutchValue = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 15)), "autoX_clutchValue");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 71, 2171U, (void *)

    &chartInstance->c1_b_autoX_clutchValue);

  chartInstance->c1_autoX_dtRelease = c1_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 16)), "autoX_dtRelease");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 66, 961U, (void *)

    &chartInstance->c1_autoX_dtRelease);

  chartInstance->c1_b_autoX_dtRelease = c1_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 17)), "autoX_dtRelease");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 73, 2173U, (void *)

    &chartInstance->c1_b_autoX_dtRelease);

  chartInstance->c1_buzzerCounter = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 18)), "buzzerCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 34, 1063U, (void *)

    &chartInstance->c1_buzzerCounter);

  chartInstance->c1_counterWait = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 19)), "counterWait");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 84, 950U, (void *)

    &chartInstance->c1_counterWait);

  chartInstance->c1_b_counterWait = c1_m_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 20)), "counterWait");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 88, 1068U, (void *)

    &chartInstance->c1_b_counterWait);

  chartInstance->c1_lastAacCom = c1_g_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 21)), "lastAacCom");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 31, 627U, (void *)

    &chartInstance->c1_lastAacCom);

  chartInstance->c1_lastAutoXCom = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 22)), "lastAutoXCom");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 33, 1043U, (void *)

    &chartInstance->c1_lastAutoXCom);

  chartInstance->c1_lastCom = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 23)), "lastCom");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 85, 484U, (void *)

    &chartInstance->c1_lastCom);

  chartInstance->c1_lastShift = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 24)), "lastShift");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 6, 715U, (void *)

    &chartInstance->c1_lastShift);

  chartInstance->c1_lastShiftCom = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 25)), "lastShiftCom");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 32, 681U, (void *)

    &chartInstance->c1_lastShiftCom);

  c1_k_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c1_u, 26)),

                        "lastTryShift", c1_uv3);

  for (c1_i96 = 0; c1_i96 < 2; c1_i96++) {

    chartInstance->c1_lastTryShift[c1_i96] = c1_uv3[c1_i96];

  }



  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 29, 2004U, (void *)

    &chartInstance->c1_lastTryShift);

  chartInstance->c1_startCounter = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 27)), "startCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 86, 488U, (void *)

    &chartInstance->c1_startCounter);

  chartInstance->c1_ticksCounter = c1_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 28)), "ticksCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 77, 45U, (void *)

    &chartInstance->c1_ticksCounter);

  chartInstance->c1_timerCounter = c1_g_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 29)), "timerCounter");

  c1_d_sdiStreamingWrapperFcn(chartInstance, 0, 87, 938U, (void *)

    &chartInstance->c1_timerCounter);

  chartInstance->c1_is_active_c1_GCU_Model_genCode = c1_c_emlrt_marshallIn

    (chartInstance, sf_mex_dup(sf_mex_getcell(c1_u, 30)),

     "is_active_c1_GCU_Model_genCode");

  chartInstance->c1_is_active_GEARSHIFT = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 31)), "is_active_GEARSHIFT");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 41, 1U, (int32_T)

    (chartInstance->c1_is_active_GEARSHIFT == 1));

  chartInstance->c1_is_active_NEUTRAL_STATE = c1_c_emlrt_marshallIn

    (chartInstance, sf_mex_dup(sf_mex_getcell(c1_u, 32)),

     "is_active_NEUTRAL_STATE");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 36, 31U, (int32_T)

    (chartInstance->c1_is_active_NEUTRAL_STATE == 1));

  chartInstance->c1_is_active_MODES = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 33)), "is_active_MODES");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 1, 418U, (int32_T)

    (chartInstance->c1_is_active_MODES == 1));

  chartInstance->c1_is_active_START_ENGINE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 34)), "is_active_START_ENGINE");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 67, 479U, (int32_T)

    (chartInstance->c1_is_active_START_ENGINE == 1));

  chartInstance->c1_is_active_SCAN_ADC = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 35)), "is_active_SCAN_ADC");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 71, 929U, (int32_T)

    (chartInstance->c1_is_active_SCAN_ADC == 1));

  chartInstance->c1_is_active_EEPROM_TRIGGER = c1_c_emlrt_marshallIn

    (chartInstance, sf_mex_dup(sf_mex_getcell(c1_u, 36)),

     "is_active_EEPROM_TRIGGER");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 73, 940U, (int32_T)

    (chartInstance->c1_is_active_EEPROM_TRIGGER == 1));

  chartInstance->c1_is_active_ANTISTALL_ENABLE = c1_c_emlrt_marshallIn

    (chartInstance, sf_mex_dup(sf_mex_getcell(c1_u, 37)),

     "is_active_ANTISTALL_ENABLE");

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 76, 1069U, (int32_T)

    (chartInstance->c1_is_active_ANTISTALL_ENABLE == 1));

  chartInstance->c1_is_GEARSHIFT = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 38)), "is_GEARSHIFT");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 41, 1U, (void *)

    &chartInstance->c1_is_GEARSHIFT);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 42, 697U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 52, 18U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 53, 5U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 54, 7U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 55, 693U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 5));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 66, 13U, (int32_T)

    (chartInstance->c1_is_GEARSHIFT == 6));

  chartInstance->c1_is_UP_START = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 39)), "is_UP_START");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 63, 9U, (void *)

    &chartInstance->c1_is_UP_START);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 64, 385U, (int32_T)

    (chartInstance->c1_is_UP_START == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 65, 383U, (int32_T)

    (chartInstance->c1_is_UP_START == 2));

  chartInstance->c1_is_UP_PUSH = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 40)), "is_UP_PUSH");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 57, 10U, (void *)

    &chartInstance->c1_is_UP_PUSH);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 58, 423U, (int32_T)

    (chartInstance->c1_is_UP_PUSH == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 59, 422U, (int32_T)

    (chartInstance->c1_is_UP_PUSH == 2));

  chartInstance->c1_is_UP_REBOUND = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 41)), "is_UP_REBOUND");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 60, 11U, (void *)

    &chartInstance->c1_is_UP_REBOUND);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 61, 390U, (int32_T)

    (chartInstance->c1_is_UP_REBOUND == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 62, 391U, (int32_T)

    (chartInstance->c1_is_UP_REBOUND == 2));

  chartInstance->c1_is_DOWN_START = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 42)), "is_DOWN_START");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 48, 14U, (void *)

    &chartInstance->c1_is_DOWN_START);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 49, 2037U, (int32_T)

    (chartInstance->c1_is_DOWN_START == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 50, 406U, (int32_T)

    (chartInstance->c1_is_DOWN_START == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 51, 399U, (int32_T)

    (chartInstance->c1_is_DOWN_START == 3));

  chartInstance->c1_is_DOWN_BRAKE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 43)), "is_DOWN_BRAKE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 43, 17U, (void *)

    &chartInstance->c1_is_DOWN_BRAKE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 44, 410U, (int32_T)

    (chartInstance->c1_is_DOWN_BRAKE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 45, 409U, (int32_T)

    (chartInstance->c1_is_DOWN_BRAKE == 2));

  chartInstance->c1_is_NEUTRAL_STATE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 44)), "is_NEUTRAL_STATE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 36, 31U, (void *)

    &chartInstance->c1_is_NEUTRAL_STATE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 37, 36U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 38, 32U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 39, 34U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 40, 35U, (int32_T)

    (chartInstance->c1_is_NEUTRAL_STATE == 4));

  chartInstance->c1_is_MODES = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 45)), "is_MODES");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 1, 418U, (void *)

    &chartInstance->c1_is_MODES);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 2, 820U, (int32_T)

    (chartInstance->c1_is_MODES == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 12, 1157U, (int32_T)

    (chartInstance->c1_is_MODES == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 22, 951U, (int32_T)

    (chartInstance->c1_is_MODES == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 32, 429U, (int32_T)

    (chartInstance->c1_is_MODES == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 33, 727U, (int32_T)

    (chartInstance->c1_is_MODES == 5));

  chartInstance->c1_is_ACC = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 46)), "is_ACC");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 3, 434U, (void *)

    &chartInstance->c1_is_ACC);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 4, 538U, (int32_T)

    (chartInstance->c1_is_ACC == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 10, 515U, (int32_T)

    (chartInstance->c1_is_ACC == 2));

  chartInstance->c1_is_START_ENGINE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 47)), "is_START_ENGINE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 67, 479U, (void *)

    &chartInstance->c1_is_START_ENGINE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 68, 482U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 69, 483U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 70, 494U, (int32_T)

    (chartInstance->c1_is_START_ENGINE == 3));

  chartInstance->c1_is_ACTIVE = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 48)), "is_ACTIVE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 4, 538U, (void *)

    &chartInstance->c1_is_ACTIVE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 5, 545U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 6, 544U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 7, 514U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 8, 543U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 9, 547U, (int32_T)

    (chartInstance->c1_is_ACTIVE == 5));

  chartInstance->c1_is_UPSHIFTING = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 49)), "is_UPSHIFTING");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 55, 693U, (void *)

    &chartInstance->c1_is_UPSHIFTING);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 56, 12U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 57, 10U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 60, 11U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 63, 9U, (int32_T)

    (chartInstance->c1_is_UPSHIFTING == 4));

  chartInstance->c1_is_DOWNSHIFTING = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 50)), "is_DOWNSHIFTING");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 42, 697U, (void *)

    &chartInstance->c1_is_DOWNSHIFTING);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 43, 17U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 46, 15U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 47, 16U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 48, 14U, (int32_T)

    (chartInstance->c1_is_DOWNSHIFTING == 4));

  chartInstance->c1_is_MANUAL_MODES = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 51)), "is_MANUAL_MODES");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 33, 727U, (void *)

    &chartInstance->c1_is_MANUAL_MODES);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 34, 729U, (int32_T)

    (chartInstance->c1_is_MANUAL_MODES == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 35, 728U, (int32_T)

    (chartInstance->c1_is_MANUAL_MODES == 2));

  chartInstance->c1_is_ACCELERATION = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 52)), "is_ACCELERATION");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 2, 820U, (void *)

    &chartInstance->c1_is_ACCELERATION);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 3, 434U, (int32_T)

    (chartInstance->c1_is_ACCELERATION == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 11, 821U, (int32_T)

    (chartInstance->c1_is_ACCELERATION == 2));

  chartInstance->c1_is_SCAN_ADC = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 53)), "is_SCAN_ADC");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 71, 929U, (void *)

    &chartInstance->c1_is_SCAN_ADC);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 72, 932U, (int32_T)

    (chartInstance->c1_is_SCAN_ADC == 1));

  chartInstance->c1_is_EEPROM_TRIGGER = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 54)), "is_EEPROM_TRIGGER");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 73, 940U, (void *)

    &chartInstance->c1_is_EEPROM_TRIGGER);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 74, 946U, (int32_T)

    (chartInstance->c1_is_EEPROM_TRIGGER == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 75, 944U, (int32_T)

    (chartInstance->c1_is_EEPROM_TRIGGER == 2));

  chartInstance->c1_is_AUTOCROSS = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 55)), "is_AUTOCROSS");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 22, 951U, (void *)

    &chartInstance->c1_is_AUTOCROSS);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 23, 952U, (int32_T)

    (chartInstance->c1_is_AUTOCROSS == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 24, 974U, (int32_T)

    (chartInstance->c1_is_AUTOCROSS == 2));

  chartInstance->c1_is_LAUNCH = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 56)), "is_LAUNCH");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 24, 974U, (void *)

    &chartInstance->c1_is_LAUNCH);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 25, 985U, (int32_T)

    (chartInstance->c1_is_LAUNCH == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 31, 1028U, (int32_T)

    (chartInstance->c1_is_LAUNCH == 2));

  chartInstance->c1_b_is_ACTIVE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 57)), "is_ACTIVE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 25, 985U, (void *)

    &chartInstance->c1_b_is_ACTIVE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 26, 999U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 27, 1025U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 28, 1002U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 29, 998U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 30, 1001U, (int32_T)

    (chartInstance->c1_b_is_ACTIVE == 5));

  chartInstance->c1_is_ANTISTALL_ENABLE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 58)), "is_ANTISTALL_ENABLE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 76, 1069U, (void *)

    &chartInstance->c1_is_ANTISTALL_ENABLE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 77, 1070U, (int32_T)

    (chartInstance->c1_is_ANTISTALL_ENABLE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 78, 1072U, (int32_T)

    (chartInstance->c1_is_ANTISTALL_ENABLE == 2));

  chartInstance->c1_is_ACCELERATION_PID = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 59)), "is_ACCELERATION_PID");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 12, 1157U, (void *)

    &chartInstance->c1_is_ACCELERATION_PID);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 13, 1091U, (int32_T)

    (chartInstance->c1_is_ACCELERATION_PID == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 14, 2174U, (int32_T)

    (chartInstance->c1_is_ACCELERATION_PID == 2));

  chartInstance->c1_is_LAUNCH0 = c1_c_emlrt_marshallIn(chartInstance, sf_mex_dup

    (sf_mex_getcell(c1_u, 60)), "is_LAUNCH0");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 14, 2174U, (void *)

    &chartInstance->c1_is_LAUNCH0);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 15, 2182U, (int32_T)

    (chartInstance->c1_is_LAUNCH0 == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 21, 2223U, (int32_T)

    (chartInstance->c1_is_LAUNCH0 == 2));

  chartInstance->c1_c_is_ACTIVE = c1_c_emlrt_marshallIn(chartInstance,

    sf_mex_dup(sf_mex_getcell(c1_u, 61)), "is_ACTIVE");

  c1_b_sdiStreamingWrapperFcn(chartInstance, 1, 15, 2182U, (void *)

    &chartInstance->c1_c_is_ACTIVE);

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 16, 2192U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 1));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 17, 2238U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 2));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 18, 2848U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 3));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 19, 2193U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 4));

  c1_sdiStreamingWrapperFcn(chartInstance, 4, 20, 2191U, (int32_T)

    (chartInstance->c1_c_is_ACTIVE == 5));

  sf_mex_assign(&chartInstance->c1_setSimStateSideEffectsInfo,

                c1_s_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell

    (c1_u, 62)), "setSimStateSideEffectsInfo"), true);

  sf_mex_destroy(&c1_u);

}



static const mxArray *c1_s_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_b_setSimStateSideEffectsInfo, const char_T

  *c1_identifier)

{

  const mxArray *c1_y = NULL;

  emlrtMsgIdentifier c1_thisId;

  c1_y = NULL;

  c1_thisId.fIdentifier = (const char *)c1_identifier;

  c1_thisId.fParent = NULL;

  c1_thisId.bParentIsCell = false;

  sf_mex_assign(&c1_y, c1_t_emlrt_marshallIn(chartInstance, sf_mex_dup

    (c1_b_setSimStateSideEffectsInfo), &c1_thisId), false);

  sf_mex_destroy(&c1_b_setSimStateSideEffectsInfo);

  return c1_y;

}



static const mxArray *c1_t_emlrt_marshallIn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)

{

  const mxArray *c1_y = NULL;

  (void)chartInstance;

  (void)c1_parentId;

  c1_y = NULL;

  sf_mex_assign(&c1_y, sf_mex_duplicatearraysafe(&c1_u), false);

  sf_mex_destroy(&c1_u);

  return c1_y;

}



static const mxArray *sf_get_hover_data_for_msg

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance, int32_T c1_ssid)

{

  (void)chartInstance;

  (void)c1_ssid;

  return NULL;

}



static void c1_init_sf_message_store_memory(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  (void)chartInstance;

}



static int32_T c1_div_nzp_s32(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_numerator, int32_T c1_denominator, uint32_T

  c1_ssid_src_loc, int32_T c1_offset_src_loc, int32_T c1_length_src_loc)

{

  int32_T c1_quotient;

  uint32_T c1_absNumerator;

  uint32_T c1_absDenominator;

  boolean_T c1_quotientNeedsNegation;

  uint32_T c1_tempAbsQuotient;

  (void)chartInstance;

  (void)c1_ssid_src_loc;

  (void)c1_offset_src_loc;

  (void)c1_length_src_loc;

  if (c1_numerator < 0) {

    c1_absNumerator = ~(uint32_T)c1_numerator + 1U;

  } else {

    c1_absNumerator = (uint32_T)c1_numerator;

  }



  if (c1_denominator < 0) {

    c1_absDenominator = ~(uint32_T)c1_denominator + 1U;

  } else {

    c1_absDenominator = (uint32_T)c1_denominator;

  }



  c1_quotientNeedsNegation = ((c1_numerator < 0) != (c1_denominator < 0));

  c1_tempAbsQuotient = c1_absNumerator / c1_absDenominator;

  if (c1_quotientNeedsNegation) {

    c1_quotient = -(int32_T)c1_tempAbsQuotient;

  } else {

    c1_quotient = (int32_T)c1_tempAbsQuotient;

  }



  return c1_quotient;

}



static int32_T c1__s32_add__(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance,

  int32_T c1_b, int32_T c1_c, uint32_T c1_ssid_src_loc, int32_T

  c1_offset_src_loc, int32_T c1_length_src_loc)

{

  int32_T c1_a;

  (void)chartInstance;

  c1_a = c1_b + c1_c;

  if (((c1_a ^ c1_b) & (c1_a ^ c1_c)) < 0) {

    _SFD_OVERFLOW_DETECTION(SFDB_OVERFLOW, c1_ssid_src_loc, c1_offset_src_loc,

      c1_length_src_loc);

  }



  return c1_a;

}



static int32_T c1__s32_minus__(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_b, int32_T c1_c, uint32_T c1_ssid_src_loc, int32_T

  c1_offset_src_loc, int32_T c1_length_src_loc)

{

  int32_T c1_a;

  (void)chartInstance;

  c1_a = c1_b - c1_c;

  if (((c1_b ^ c1_a) & (c1_b ^ c1_c)) < 0) {

    _SFD_OVERFLOW_DETECTION(SFDB_OVERFLOW, c1_ssid_src_loc, c1_offset_src_loc,

      c1_length_src_loc);

  }



  return c1_a;

}



static uint8_T c1__u8_s32_(SFc1_GCU_Model_genCodeInstanceStruct *chartInstance,

  int32_T c1_b, uint32_T c1_ssid_src_loc, int32_T c1_offset_src_loc, int32_T

  c1_length_src_loc)

{

  uint8_T c1_a;

  (void)chartInstance;

  c1_a = (uint8_T)c1_b;

  if (c1_a != c1_b) {

    _SFD_OVERFLOW_DETECTION(SFDB_OVERFLOW, c1_ssid_src_loc, c1_offset_src_loc,

      c1_length_src_loc);

  }



  return c1_a;

}



static void c1_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  int32_T c1_streamedData)

{

  if (chartInstance->c1_sdiLoggedStatesBuffer[c1_ssidIdx] & (uint8_T)c1_modeFlag)

  {

    sdi_update_self_activity_signal(&chartInstance->c1_sdiBlockInfo, c1_ssid,

      c1_streamedData);

  }

}



static void c1_b_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  void *c1_streamedData)

{

  if (chartInstance->c1_sdiLoggedStatesBuffer[c1_ssidIdx] & (uint8_T)c1_modeFlag)

  {

    sdi_stream_child_activity_signal(&chartInstance->c1_sdiBlockInfo, c1_ssid,

      c1_streamedData);

  }

}



static void c1_c_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  int32_T c1_streamedData)

{

  if (chartInstance->c1_sdiLoggedStatesBuffer[c1_ssidIdx] & (uint8_T)c1_modeFlag)

  {

    sdi_update_leaf_activity_signal(&chartInstance->c1_sdiBlockInfo, c1_ssid,

      c1_streamedData);

  }

}



static void c1_d_sdiStreamingWrapperFcn(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance, int32_T c1_modeFlag, int32_T c1_ssidIdx, uint32_T c1_ssid,

  void *c1_streamedData)

{

  (void)c1_modeFlag;

  if (chartInstance->c1_sdiLoggedDataBuffer[c1_ssidIdx]) {

    sdi_stream_data_signal(&chartInstance->c1_sdiBlockInfo, c1_ssid,

      c1_streamedData);

  }

}



static void init_test_point_addr_map(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  chartInstance->c1_testPointAddrMap[0] = chartInstance->c1_clutchCurrVal;

  chartInstance->c1_testPointAddrMap[1] = &chartInstance->c1_aacCounter;

  chartInstance->c1_testPointAddrMap[2] = &chartInstance->c1_autoXCounter;

  chartInstance->c1_testPointAddrMap[3] = &chartInstance->c1_b_autoXCounter;

}



static void **get_test_point_address_map(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  return &chartInstance->c1_testPointAddrMap[0];

}



static rtwCAPI_ModelMappingInfo *get_test_point_mapping_info

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  return &chartInstance->c1_testPointMappingInfo;

}



static void **get_dataset_logging_obj_vector

  (SFc1_GCU_Model_genCodeInstanceStruct *chartInstance)

{

  return &chartInstance->c1_dataSetLogObjVector[0];

}



static void init_dsm_address_info(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  (void)chartInstance;

}



static void init_simulink_io_address(SFc1_GCU_Model_genCodeInstanceStruct

  *chartInstance)

{

  chartInstance->c1_fEmlrtCtx = (void *)sfrtGetEmlrtCtx(chartInstance->S);

  chartInstance->c1_clutchCurrVal = (uint8_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 1);

  chartInstance->c1_lastModeCom = (uint16_T (*)[2])ssGetOutputPortSignal_wrapper

    (chartInstance->S, 2);

  chartInstance->c1_shiftCom = (uint16_T (*)[2])ssGetInputPortSignal_wrapper

    (chartInstance->S, 0);

  chartInstance->c1_startEngCom = (uint8_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 1);

  chartInstance->c1_aacCom = (uint16_T (*)[2])ssGetInputPortSignal_wrapper

    (chartInstance->S, 2);

  chartInstance->c1_clutchTarget = (uint8_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 3);

  chartInstance->c1_modeCom = (uint16_T (*)[2])ssGetInputPortSignal_wrapper

    (chartInstance->S, 4);

  chartInstance->c1_stateFb = (uint16_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 3);

  chartInstance->c1_acc_parameters = (int32_T (*)[16])

    ssGetInputPortSignal_wrapper(chartInstance->S, 5);

  chartInstance->c1_timings = (int32_T (*)[24])ssGetInputPortSignal_wrapper

    (chartInstance->S, 6);

  chartInstance->c1_autoXCom = (uint16_T (*)[2])ssGetInputPortSignal_wrapper

    (chartInstance->S, 7);

  chartInstance->c1_autoX_parameters = (int32_T (*)[16])

    ssGetInputPortSignal_wrapper(chartInstance->S, 8);

  chartInstance->c1_slipUpdateCounter = (uint8_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 9);

  chartInstance->c1_antiStallEnable = (uint8_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 4);

  chartInstance->c1_antiStall_parameters = (int32_T (*)[8])

    ssGetInputPortSignal_wrapper(chartInstance->S, 10);

  chartInstance->c1_antiStallFb = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 11);

  chartInstance->c1_gearMotorCurent_1_2 = (uint32_T (*)[2])

    ssGetInputPortSignal_wrapper(chartInstance->S, 12);

  chartInstance->c1_currGear = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 13);

  chartInstance->c1_currTps = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 14);

  chartInstance->c1_currRpm = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 15);

  chartInstance->c1_currVhSpeed = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 16);

  chartInstance->c1_currSlip = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 17);

  chartInstance->c1_currSlipTarget = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 18);

  chartInstance->c1_pidSubMode = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 19);

  chartInstance->c1_pidCounter = (uint32_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 5);

  chartInstance->c1_I1_L = (real_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 20);

  chartInstance->c1_I2_L = (real_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 21);

  chartInstance->c1_canErrorCom = (uint16_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 22);

  chartInstance->c1_rpmAccTarget = (uint16_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 6);

  chartInstance->c1_b_clutchCurrVal = (real_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 23);

  chartInstance->c1_out = (boolean_T *)ssGetInputPortSignal_wrapper

    (chartInstance->S, 33);

  chartInstance->c1_time = (real_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 27);

  chartInstance->c1_current = (real_T *)ssGetOutputPortSignal_wrapper

    (chartInstance->S, 28);

}



/* SFunction Glue Code */

#ifdef utFree

#undef utFree

#endif



#ifdef utMalloc

#undef utMalloc

#endif



#ifdef __cplusplus



extern "C" void *utMalloc(size_t size);

extern "C" void utFree(void*);



#else



extern void *utMalloc(size_t size);

extern void utFree(void*);



#endif



static void init_test_point_mapping_info(SimStruct *S);

void sf_c1_GCU_Model_genCode_get_check_sum(mxArray *plhs[])

{

  ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(850943356U);

  ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1716702901U);

  ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(976523448U);

  ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(11182174U);

}



mxArray* sf_c1_GCU_Model_genCode_get_post_codegen_info(void);

mxArray *sf_c1_GCU_Model_genCode_get_autoinheritance_info(void)

{

  const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters",

    "outputs", "locals", "postCodegenInfo" };



  mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1, 1, sizeof

    (autoinheritanceFields)/sizeof(autoinheritanceFields[0]),

    autoinheritanceFields);



  {

    mxArray *mxChecksum = mxCreateString("2ftyJstvDiOT3XMgn2Im9");

    mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum);

  }



  {

    const char *dataFields[] = { "size", "type", "complexity" };



    mxArray *mxData = mxCreateStructMatrix(1,23,3,dataFields);



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(2);

      mxSetField(mxData,0,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,0,"type",mxType);

    }



    mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,1,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(3));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,1,"type",mxType);

    }



    mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(2);

      mxSetField(mxData,2,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,2,"type",mxType);

    }



    mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,3,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(3));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,3,"type",mxType);

    }



    mxSetField(mxData,3,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(2);

      mxSetField(mxData,4,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,4,"type",mxType);

    }



    mxSetField(mxData,4,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(16);

      mxSetField(mxData,5,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(8));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,5,"type",mxType);

    }



    mxSetField(mxData,5,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(24);

      mxSetField(mxData,6,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(8));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,6,"type",mxType);

    }



    mxSetField(mxData,6,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(2);

      mxSetField(mxData,7,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,7,"type",mxType);

    }



    mxSetField(mxData,7,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(16);

      mxSetField(mxData,8,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(8));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,8,"type",mxType);

    }



    mxSetField(mxData,8,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,9,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(3));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,9,"type",mxType);

    }



    mxSetField(mxData,9,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(1);

      pr[1] = (double)(8);

      mxSetField(mxData,10,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(8));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,10,"type",mxType);

    }



    mxSetField(mxData,10,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,11,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,11,"type",mxType);

    }



    mxSetField(mxData,11,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,1,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(2);

      mxSetField(mxData,12,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(7));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,12,"type",mxType);

    }



    mxSetField(mxData,12,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,13,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,13,"type",mxType);

    }



    mxSetField(mxData,13,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,14,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,14,"type",mxType);

    }



    mxSetField(mxData,14,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,15,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,15,"type",mxType);

    }



    mxSetField(mxData,15,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,16,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,16,"type",mxType);

    }



    mxSetField(mxData,16,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,17,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,17,"type",mxType);

    }



    mxSetField(mxData,17,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,18,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,18,"type",mxType);

    }



    mxSetField(mxData,18,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,19,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,19,"type",mxType);

    }



    mxSetField(mxData,19,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,20,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(10));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,20,"type",mxType);

    }



    mxSetField(mxData,20,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,21,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(10));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,21,"type",mxType);

    }



    mxSetField(mxData,21,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,22,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,22,"type",mxType);

    }



    mxSetField(mxData,22,"complexity",mxCreateDoubleScalar(0));

    mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData);

  }



  {

    mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0,

                mxREAL));

  }



  {

    const char *dataFields[] = { "size", "type", "complexity" };



    mxArray *mxData = mxCreateStructMatrix(1,6,3,dataFields);



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,0,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(3));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,0,"type",mxType);

    }



    mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,1,mxREAL);

      double *pr = mxGetPr(mxSize);

      pr[0] = (double)(2);

      mxSetField(mxData,1,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,1,"type",mxType);

    }



    mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,2,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,2,"type",mxType);

    }



    mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,3,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(3));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,3,"type",mxType);

    }



    mxSetField(mxData,3,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,4,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(7));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,4,"type",mxType);

    }



    mxSetField(mxData,4,"complexity",mxCreateDoubleScalar(0));



    {

      mxArray *mxSize = mxCreateDoubleMatrix(1,0,mxREAL);

      double *pr = mxGetPr(mxSize);

      mxSetField(mxData,5,"size",mxSize);

    }



    {

      const char *typeFields[] = { "base", "fixpt", "isFixedPointType" };



      mxArray *mxType = mxCreateStructMatrix(1,1,sizeof(typeFields)/sizeof

        (typeFields[0]),typeFields);

      mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));

      mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL));

      mxSetField(mxType,0,"isFixedPointType",mxCreateDoubleScalar(0));

      mxSetField(mxData,5,"type",mxType);

    }



    mxSetField(mxData,5,"complexity",mxCreateDoubleScalar(0));

    mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData);

  }



  {

    mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL));

  }



  {

    mxArray* mxPostCodegenInfo = sf_c1_GCU_Model_genCode_get_post_codegen_info();

    mxSetField(mxAutoinheritanceInfo,0,"postCodegenInfo",mxPostCodegenInfo);

  }



  return(mxAutoinheritanceInfo);

}



mxArray *sf_c1_GCU_Model_genCode_third_party_uses_info(void)

{

  mxArray * mxcell3p = mxCreateCellMatrix(1,0);

  return(mxcell3p);

}



mxArray *sf_c1_GCU_Model_genCode_jit_fallback_info(void)

{

  const char *infoFields[] = { "fallbackType", "fallbackReason",

    "hiddenFallbackType", "hiddenFallbackReason", "incompatibleSymbol" };



  mxArray *mxInfo = mxCreateStructMatrix(1, 1, 5, infoFields);

  mxArray *fallbackType = mxCreateString("early");

  mxArray *fallbackReason = mxCreateString("custom_code");

  mxArray *hiddenFallbackType = mxCreateString("");

  mxArray *hiddenFallbackReason = mxCreateString("");

  mxArray *incompatibleSymbol = mxCreateString("");

  mxSetField(mxInfo, 0, infoFields[0], fallbackType);

  mxSetField(mxInfo, 0, infoFields[1], fallbackReason);

  mxSetField(mxInfo, 0, infoFields[2], hiddenFallbackType);

  mxSetField(mxInfo, 0, infoFields[3], hiddenFallbackReason);

  mxSetField(mxInfo, 0, infoFields[4], incompatibleSymbol);

  return mxInfo;

}



mxArray *sf_c1_GCU_Model_genCode_updateBuildInfo_args_info(void)

{

  mxArray *mxBIArgs = mxCreateCellMatrix(1,0);

  return mxBIArgs;

}



mxArray* sf_c1_GCU_Model_genCode_get_post_codegen_info(void)

{

  const char* fieldNames[] = { "exportedFunctionsUsedByThisChart",

    "exportedFunctionsChecksum" };



  mwSize dims[2] = { 1, 1 };



  mxArray* mxPostCodegenInfo = mxCreateStructArray(2, dims, sizeof(fieldNames)/

    sizeof(fieldNames[0]), fieldNames);



  {

    mxArray* mxExportedFunctionsChecksum = mxCreateString("");

    mwSize exp_dims[2] = { 0, 1 };



    mxArray* mxExportedFunctionsUsedByThisChart = mxCreateCellArray(2, exp_dims);

    mxSetField(mxPostCodegenInfo, 0, "exportedFunctionsUsedByThisChart",

               mxExportedFunctionsUsedByThisChart);

    mxSetField(mxPostCodegenInfo, 0, "exportedFunctionsChecksum",

               mxExportedFunctionsChecksum);

  }



  return mxPostCodegenInfo;

}



static const mxArray *sf_get_sim_state_info_c1_GCU_Model_genCode(void)

{

  const char *infoFields[] = { "chartChecksum", "varInfo" };



  mxArray *mxInfo = mxCreateStructMatrix(1, 1, 2, infoFields);

  const char *infoEncStr[] = {

    "100 S1x10'type','srcId','name','auxInfo'{{M[1],M[1073],T\"antiStallEnable\",},{M[1],M[123],T\"clutchCurrVal\",},{M[1],M[834],T\"lastModeCom\",},{M[1],M[1839],T\"pidCounter\",},{M[1],M[2851],T\"rpmAccTarget\",},{M[1],M[833],T\"stateFb\",},{M[3],M[550],T\"aacCounter\",},{M[3],M[563],T\"aac_clutchStep\",},{M[3],M[561],T\"aac_clutchValue\",},{M[3],M[564],T\"aac_dtRelease\",}}",

    "100 S1x10'type','srcId','name','auxInfo'{{M[3],M[958],T\"autoXCounter\",},{M[3],M[2170],T\"autoXCounter\",},{M[3],M[960],T\"autoX_clutchStep\",},{M[3],M[2172],T\"autoX_clutchStep\",},{M[3],M[959],T\"autoX_clutchValue\",},{M[3],M[2171],T\"autoX_clutchValue\",},{M[3],M[961],T\"autoX_dtRelease\",},{M[3],M[2173],T\"autoX_dtRelease\",},{M[3],M[1063],T\"buzzerCounter\",},{M[3],M[950],T\"counterWait\",}}",

    "100 S1x10'type','srcId','name','auxInfo'{{M[3],M[1068],T\"counterWait\",},{M[3],M[627],T\"lastAacCom\",},{M[3],M[1043],T\"lastAutoXCom\",},{M[3],M[484],T\"lastCom\",},{M[3],M[715],T\"lastShift\",},{M[3],M[681],T\"lastShiftCom\",},{M[3],M[2004],T\"lastTryShift\",},{M[3],M[488],T\"startCounter\",},{M[3],M[45],T\"ticksCounter\",},{M[3],M[938],T\"timerCounter\",}}",

    "100 S1x10'type','srcId','name','auxInfo'{{M[8],M[0],T\"is_active_c1_GCU_Model_genCode\",},{M[8],M[1],T\"is_active_GEARSHIFT\",},{M[8],M[31],T\"is_active_NEUTRAL_STATE\",},{M[8],M[418],T\"is_active_MODES\",},{M[8],M[479],T\"is_active_START_ENGINE\",},{M[8],M[929],T\"is_active_SCAN_ADC\",},{M[8],M[940],T\"is_active_EEPROM_TRIGGER\",},{M[8],M[1069],T\"is_active_ANTISTALL_ENABLE\",},{M[9],M[1],T\"is_GEARSHIFT\",},{M[9],M[9],T\"is_UP_START\",}}",

    "100 S1x10'type','srcId','name','auxInfo'{{M[9],M[10],T\"is_UP_PUSH\",},{M[9],M[11],T\"is_UP_REBOUND\",},{M[9],M[14],T\"is_DOWN_START\",},{M[9],M[17],T\"is_DOWN_BRAKE\",},{M[9],M[31],T\"is_NEUTRAL_STATE\",},{M[9],M[418],T\"is_MODES\",},{M[9],M[434],T\"is_ACC\",},{M[9],M[479],T\"is_START_ENGINE\",},{M[9],M[538],T\"is_ACTIVE\",},{M[9],M[693],T\"is_UPSHIFTING\",}}",

    "100 S1x10'type','srcId','name','auxInfo'{{M[9],M[697],T\"is_DOWNSHIFTING\",},{M[9],M[727],T\"is_MANUAL_MODES\",},{M[9],M[820],T\"is_ACCELERATION\",},{M[9],M[929],T\"is_SCAN_ADC\",},{M[9],M[940],T\"is_EEPROM_TRIGGER\",},{M[9],M[951],T\"is_AUTOCROSS\",},{M[9],M[974],T\"is_LAUNCH\",},{M[9],M[985],T\"is_ACTIVE\",},{M[9],M[1069],T\"is_ANTISTALL_ENABLE\",},{M[9],M[1157],T\"is_ACCELERATION_PID\",}}",

    "100 S1x2'type','srcId','name','auxInfo'{{M[9],M[2174],T\"is_LAUNCH0\",},{M[9],M[2182],T\"is_ACTIVE\",}}"

  };



  mxArray *mxVarInfo = sf_mex_decode_encoded_mx_struct_array(infoEncStr, 62, 10);

  mxArray *mxChecksum = mxCreateDoubleMatrix(1, 4, mxREAL);

  sf_c1_GCU_Model_genCode_get_check_sum(&mxChecksum);

  mxSetField(mxInfo, 0, infoFields[0], mxChecksum);

  mxSetField(mxInfo, 0, infoFields[1], mxVarInfo);

  return mxInfo;

}



static const mxArray* sf_opaque_get_hover_data_for_msg(void* chartInstance,

  int32_T msgSSID)

{

  return sf_get_hover_data_for_msg( (SFc1_GCU_Model_genCodeInstanceStruct *)

    chartInstance, msgSSID);

}



static void chart_debug_initialization(SimStruct *S, unsigned int

  fullDebuggerInitialization)

{

  if (!sim_mode_is_rtw_gen(S)) {

    SFc1_GCU_Model_genCodeInstanceStruct *chartInstance =

      (SFc1_GCU_Model_genCodeInstanceStruct *)sf_get_chart_instance_ptr(S);

    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {

      /* do this only if simulation is starting */

      {

        unsigned int chartAlreadyPresent;

        chartAlreadyPresent = sf_debug_initialize_chart

          (sfGlobalDebugInstanceStruct,

           _GCU_Model_genCodeMachineNumber_,

           1,

           91,

           233,

           0,

           89,

           19,

           0,

           0,

           0,

           0,

           &chartInstance->chartNumber,

           &chartInstance->instanceNumber,

           (void *)S);



        /* Each instance must initialize its own list of scripts */

        init_script_number_translation(_GCU_Model_genCodeMachineNumber_,

          chartInstance->chartNumber,chartInstance->instanceNumber);

        if (chartAlreadyPresent==0) {

          /* this is the first instance */

          sf_debug_set_chart_disable_implicit_casting

            (sfGlobalDebugInstanceStruct,_GCU_Model_genCodeMachineNumber_,

             chartInstance->chartNumber,1);

          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,

            _GCU_Model_genCodeMachineNumber_,

            chartInstance->chartNumber,

            19,

            19,

            19);

          _SFD_SET_DATA_PROPS(0,0,0,0,"buzzerCounter");

          _SFD_SET_DATA_PROPS(1,0,0,0,"lastAacCom");

          _SFD_SET_DATA_PROPS(2,0,0,0,"lastAutoXCom");

          _SFD_SET_DATA_PROPS(3,0,0,0,"lastShiftCom");

          _SFD_SET_DATA_PROPS(4,0,0,0,"aacCounter");

          _SFD_SET_DATA_PROPS(5,0,0,0,"aac_clutchStep");

          _SFD_SET_DATA_PROPS(6,0,0,0,"aac_clutchValue");

          _SFD_SET_DATA_PROPS(7,0,0,0,"aac_dtRelease");

          _SFD_SET_DATA_PROPS(8,0,0,0,"autoXCounter");

          _SFD_SET_DATA_PROPS(9,0,0,0,"autoX_clutchStep");

          _SFD_SET_DATA_PROPS(10,0,0,0,"autoX_clutchValue");

          _SFD_SET_DATA_PROPS(11,0,0,0,"autoX_dtRelease");

          _SFD_SET_DATA_PROPS(12,0,0,0,"autoXCounter");

          _SFD_SET_DATA_PROPS(13,0,0,0,"autoX_clutchStep");

          _SFD_SET_DATA_PROPS(14,0,0,0,"autoX_clutchValue");

          _SFD_SET_DATA_PROPS(15,0,0,0,"autoX_dtRelease");

          _SFD_SET_DATA_PROPS(16,0,0,0,"ticksCounter");

          _SFD_SET_DATA_PROPS(17,0,0,0,"counterWait");

          _SFD_SET_DATA_PROPS(18,0,0,0,"lastCom");

          _SFD_SET_DATA_PROPS(19,0,0,0,"startCounter");

          _SFD_SET_DATA_PROPS(20,0,0,0,"timerCounter");

          _SFD_SET_DATA_PROPS(21,0,0,0,"counterWait");

          _SFD_SET_DATA_PROPS(22,0,0,0,"lastShift");

          _SFD_SET_DATA_PROPS(23,0,0,0,"lastTryShift");

          _SFD_SET_DATA_PROPS(24,1,1,0,"shiftCom");

          _SFD_SET_DATA_PROPS(25,1,1,0,"startEngCom");

          _SFD_SET_DATA_PROPS(26,1,1,0,"aacCom");

          _SFD_SET_DATA_PROPS(27,1,1,0,"clutchTarget");

          _SFD_SET_DATA_PROPS(28,1,1,0,"modeCom");

          _SFD_SET_DATA_PROPS(29,1,1,0,"acc_parameters");

          _SFD_SET_DATA_PROPS(30,1,1,0,"timings");

          _SFD_SET_DATA_PROPS(31,1,1,0,"autoXCom");

          _SFD_SET_DATA_PROPS(32,1,1,0,"autoX_parameters");

          _SFD_SET_DATA_PROPS(33,1,1,0,"slipUpdateCounter");

          _SFD_SET_DATA_PROPS(34,1,1,0,"antiStall_parameters");

          _SFD_SET_DATA_PROPS(35,1,1,0,"antiStallFb");

          _SFD_SET_DATA_PROPS(36,1,1,0,"gearMotorCurent_1_2");

          _SFD_SET_DATA_PROPS(37,1,1,0,"currGear");

          _SFD_SET_DATA_PROPS(38,1,1,0,"currTps");

          _SFD_SET_DATA_PROPS(39,1,1,0,"currRpm");

          _SFD_SET_DATA_PROPS(40,1,1,0,"currVhSpeed");

          _SFD_SET_DATA_PROPS(41,1,1,0,"currSlip");

          _SFD_SET_DATA_PROPS(42,1,1,0,"currSlipTarget");

          _SFD_SET_DATA_PROPS(43,1,1,0,"pidSubMode");

          _SFD_SET_DATA_PROPS(44,1,1,0,"I1_L");

          _SFD_SET_DATA_PROPS(45,1,1,0,"I2_L");

          _SFD_SET_DATA_PROPS(46,1,1,0,"canErrorCom");

          _SFD_SET_DATA_PROPS(47,2,0,1,"clutchCurrVal");

          _SFD_SET_DATA_PROPS(48,2,0,1,"lastModeCom");

          _SFD_SET_DATA_PROPS(49,2,0,1,"stateFb");

          _SFD_SET_DATA_PROPS(50,2,0,1,"antiStallEnable");

          _SFD_SET_DATA_PROPS(51,2,0,1,"pidCounter");

          _SFD_SET_DATA_PROPS(52,2,0,1,"rpmAccTarget");

          _SFD_SET_DATA_PROPS(53,7,0,0,"GEAR_COMMAND_DOWN");

          _SFD_SET_DATA_PROPS(54,7,0,0,"GEAR_COMMAND_NEUTRAL_DOWN");

          _SFD_SET_DATA_PROPS(55,7,0,0,"GEAR_COMMAND_NEUTRAL_UP");

          _SFD_SET_DATA_PROPS(56,7,0,0,"GEAR_COMMAND_UP");

          _SFD_SET_DATA_PROPS(57,7,0,0,"GEAR_COMMAND_DOWN");

          _SFD_SET_DATA_PROPS(58,7,0,0,"GEAR_COMMAND_NEUTRAL_DOWN");

          _SFD_SET_DATA_PROPS(59,7,0,0,"GEAR_COMMAND_NEUTRAL_UP");

          _SFD_SET_DATA_PROPS(60,7,0,0,"GEAR_COMMAND_UP");

          _SFD_SET_DATA_PROPS(61,7,0,0,"AAC_WORK_RATE_ms");

          _SFD_SET_DATA_PROPS(62,7,0,0,"ACC_CODE");

          _SFD_SET_DATA_PROPS(63,7,0,0,"DEF_RAMP_END");

          _SFD_SET_DATA_PROPS(64,7,0,0,"DEF_RAMP_START");

          _SFD_SET_DATA_PROPS(65,7,0,0,"DEF_RAMP_TIME");

          _SFD_SET_DATA_PROPS(66,7,0,0,"DEF_RPM_LIMIT_1_2");

          _SFD_SET_DATA_PROPS(67,7,0,0,"DEF_RPM_LIMIT_2_3");

          _SFD_SET_DATA_PROPS(68,7,0,0,"DEF_RPM_LIMIT_3_4");

          _SFD_SET_DATA_PROPS(69,7,0,0,"DEF_RPM_LIMIT_4_5");

          _SFD_SET_DATA_PROPS(70,7,0,0,"DEF_SPEED_LIMIT_1_2");

          _SFD_SET_DATA_PROPS(71,7,0,0,"DEF_SPEED_LIMIT_2_3");

          _SFD_SET_DATA_PROPS(72,7,0,0,"DEF_SPEED_LIMIT_3_4");

          _SFD_SET_DATA_PROPS(73,7,0,0,"DEF_SPEED_LIMIT_4_5");

          _SFD_SET_DATA_PROPS(74,7,0,0,"AUTOX_WORK_RATE_ms");

          _SFD_SET_DATA_PROPS(75,7,0,0,"AUTOX_WORK_RATE_ms");

          _SFD_SET_DATA_PROPS(76,7,0,0,"data");

          _SFD_SET_DATA_PROPS(77,8,0,0,"");

          _SFD_SET_DATA_PROPS(78,8,0,0,"");

          _SFD_SET_DATA_PROPS(79,8,0,0,"");

          _SFD_SET_DATA_PROPS(80,8,0,0,"");

          _SFD_SET_DATA_PROPS(81,8,0,0,"");

          _SFD_SET_DATA_PROPS(82,8,0,0,"");

          _SFD_SET_DATA_PROPS(83,9,0,0,"");

          _SFD_SET_DATA_PROPS(84,9,0,0,"");

          _SFD_SET_DATA_PROPS(85,9,0,0,"");

          _SFD_SET_DATA_PROPS(86,9,0,0,"");

          _SFD_SET_DATA_PROPS(87,9,0,0,"");

          _SFD_SET_DATA_PROPS(88,9,0,0,"");

          _SFD_EVENT_SCOPE(0,0);

          _SFD_EVENT_SCOPE(1,0);

          _SFD_EVENT_SCOPE(2,0);

          _SFD_EVENT_SCOPE(3,2);

          _SFD_EVENT_SCOPE(4,2);

          _SFD_EVENT_SCOPE(5,2);

          _SFD_EVENT_SCOPE(6,2);

          _SFD_EVENT_SCOPE(7,2);

          _SFD_EVENT_SCOPE(8,2);

          _SFD_EVENT_SCOPE(9,2);

          _SFD_EVENT_SCOPE(10,2);

          _SFD_EVENT_SCOPE(11,2);

          _SFD_EVENT_SCOPE(12,2);

          _SFD_EVENT_SCOPE(13,2);

          _SFD_EVENT_SCOPE(14,2);

          _SFD_EVENT_SCOPE(15,2);

          _SFD_EVENT_SCOPE(16,2);

          _SFD_EVENT_SCOPE(17,2);

          _SFD_EVENT_SCOPE(18,2);

          _SFD_STATE_INFO(0,0,1);

          _SFD_STATE_INFO(1,0,0);

          _SFD_STATE_INFO(2,0,0);

          _SFD_STATE_INFO(4,0,1);

          _SFD_STATE_INFO(5,0,0);

          _SFD_STATE_INFO(6,0,0);

          _SFD_STATE_INFO(7,0,1);

          _SFD_STATE_INFO(8,0,0);

          _SFD_STATE_INFO(9,0,0);

          _SFD_STATE_INFO(10,0,0);

          _SFD_STATE_INFO(11,0,0);

          _SFD_STATE_INFO(12,0,0);

          _SFD_STATE_INFO(13,0,0);

          _SFD_STATE_INFO(14,0,0);

          _SFD_STATE_INFO(15,0,0);

          _SFD_STATE_INFO(16,0,0);

          _SFD_STATE_INFO(17,0,0);

          _SFD_STATE_INFO(18,0,0);

          _SFD_STATE_INFO(20,0,0);

          _SFD_STATE_INFO(21,0,0);

          _SFD_STATE_INFO(22,0,0);

          _SFD_STATE_INFO(23,0,0);

          _SFD_STATE_INFO(24,0,0);

          _SFD_STATE_INFO(25,0,0);

          _SFD_STATE_INFO(26,0,0);

          _SFD_STATE_INFO(27,0,0);

          _SFD_STATE_INFO(28,0,0);

          _SFD_STATE_INFO(29,0,0);

          _SFD_STATE_INFO(30,0,0);

          _SFD_STATE_INFO(31,0,0);

          _SFD_STATE_INFO(32,0,0);

          _SFD_STATE_INFO(33,0,0);

          _SFD_STATE_INFO(35,0,1);

          _SFD_STATE_INFO(36,0,0);

          _SFD_STATE_INFO(37,0,0);

          _SFD_STATE_INFO(38,0,0);

          _SFD_STATE_INFO(39,0,0);

          _SFD_STATE_INFO(40,0,0);

          _SFD_STATE_INFO(41,0,0);

          _SFD_STATE_INFO(42,0,0);

          _SFD_STATE_INFO(43,0,0);

          _SFD_STATE_INFO(45,0,0);

          _SFD_STATE_INFO(47,0,0);

          _SFD_STATE_INFO(48,0,0);

          _SFD_STATE_INFO(49,0,0);

          _SFD_STATE_INFO(50,0,0);

          _SFD_STATE_INFO(51,0,0);

          _SFD_STATE_INFO(52,0,0);

          _SFD_STATE_INFO(53,0,0);

          _SFD_STATE_INFO(54,0,0);

          _SFD_STATE_INFO(55,0,0);

          _SFD_STATE_INFO(56,0,0);

          _SFD_STATE_INFO(59,0,0);

          _SFD_STATE_INFO(61,0,0);

          _SFD_STATE_INFO(62,0,0);

          _SFD_STATE_INFO(63,0,0);

          _SFD_STATE_INFO(64,0,0);

          _SFD_STATE_INFO(65,0,0);

          _SFD_STATE_INFO(66,0,0);

          _SFD_STATE_INFO(67,0,0);

          _SFD_STATE_INFO(68,0,0);

          _SFD_STATE_INFO(69,0,0);

          _SFD_STATE_INFO(71,0,0);

          _SFD_STATE_INFO(73,0,0);

          _SFD_STATE_INFO(74,0,0);

          _SFD_STATE_INFO(75,0,0);

          _SFD_STATE_INFO(76,0,0);

          _SFD_STATE_INFO(79,0,1);

          _SFD_STATE_INFO(80,0,0);

          _SFD_STATE_INFO(81,0,0);

          _SFD_STATE_INFO(82,0,0);

          _SFD_STATE_INFO(83,0,0);

          _SFD_STATE_INFO(84,0,1);

          _SFD_STATE_INFO(85,0,0);

          _SFD_STATE_INFO(87,0,1);

          _SFD_STATE_INFO(88,0,0);

          _SFD_STATE_INFO(89,0,0);

          _SFD_STATE_INFO(90,0,0);

          _SFD_STATE_INFO(19,0,2);

          _SFD_STATE_INFO(34,0,2);

          _SFD_STATE_INFO(44,0,2);

          _SFD_STATE_INFO(46,0,2);

          _SFD_STATE_INFO(57,0,2);

          _SFD_STATE_INFO(58,0,2);

          _SFD_STATE_INFO(60,0,2);

          _SFD_STATE_INFO(70,0,2);

          _SFD_STATE_INFO(72,0,2);

          _SFD_STATE_INFO(77,0,2);

          _SFD_STATE_INFO(78,0,2);

          _SFD_STATE_INFO(86,0,2);

          _SFD_STATE_INFO(3,0,2);

          _SFD_CH_SUBSTATE_COUNT(7);

          _SFD_CH_SUBSTATE_DECOMP(1);

          _SFD_CH_SUBSTATE_INDEX(0,35);

          _SFD_CH_SUBSTATE_INDEX(1,79);

          _SFD_CH_SUBSTATE_INDEX(2,7);

          _SFD_CH_SUBSTATE_INDEX(3,87);

          _SFD_CH_SUBSTATE_INDEX(4,84);

          _SFD_CH_SUBSTATE_INDEX(5,4);

          _SFD_CH_SUBSTATE_INDEX(6,0);

          _SFD_ST_SUBSTATE_COUNT(35,5);

          _SFD_ST_SUBSTATE_INDEX(35,0,36);

          _SFD_ST_SUBSTATE_INDEX(35,1,48);

          _SFD_ST_SUBSTATE_INDEX(35,2,61);

          _SFD_ST_SUBSTATE_INDEX(35,3,73);

          _SFD_ST_SUBSTATE_INDEX(35,4,74);

          _SFD_ST_SUBSTATE_COUNT(36,2);

          _SFD_ST_SUBSTATE_INDEX(36,0,37);

          _SFD_ST_SUBSTATE_INDEX(36,1,47);

          _SFD_ST_SUBSTATE_COUNT(37,2);

          _SFD_ST_SUBSTATE_INDEX(37,0,38);

          _SFD_ST_SUBSTATE_INDEX(37,1,45);

          _SFD_ST_SUBSTATE_COUNT(38,5);

          _SFD_ST_SUBSTATE_INDEX(38,0,39);

          _SFD_ST_SUBSTATE_INDEX(38,1,40);

          _SFD_ST_SUBSTATE_INDEX(38,2,41);

          _SFD_ST_SUBSTATE_INDEX(38,3,42);

          _SFD_ST_SUBSTATE_INDEX(38,4,43);

          _SFD_ST_SUBSTATE_COUNT(39,0);

          _SFD_ST_SUBSTATE_COUNT(40,0);

          _SFD_ST_SUBSTATE_COUNT(41,0);

          _SFD_ST_SUBSTATE_COUNT(42,0);

          _SFD_ST_SUBSTATE_COUNT(43,0);

          _SFD_ST_SUBSTATE_COUNT(45,0);

          _SFD_ST_SUBSTATE_COUNT(47,0);

          _SFD_ST_SUBSTATE_COUNT(48,2);

          _SFD_ST_SUBSTATE_INDEX(48,0,49);

          _SFD_ST_SUBSTATE_INDEX(48,1,50);

          _SFD_ST_SUBSTATE_COUNT(49,0);

          _SFD_ST_SUBSTATE_COUNT(50,2);

          _SFD_ST_SUBSTATE_INDEX(50,0,51);

          _SFD_ST_SUBSTATE_INDEX(50,1,59);

          _SFD_ST_SUBSTATE_COUNT(51,5);

          _SFD_ST_SUBSTATE_INDEX(51,0,52);

          _SFD_ST_SUBSTATE_INDEX(51,1,53);

          _SFD_ST_SUBSTATE_INDEX(51,2,54);

          _SFD_ST_SUBSTATE_INDEX(51,3,55);

          _SFD_ST_SUBSTATE_INDEX(51,4,56);

          _SFD_ST_SUBSTATE_COUNT(52,0);

          _SFD_ST_SUBSTATE_COUNT(53,0);

          _SFD_ST_SUBSTATE_COUNT(54,0);

          _SFD_ST_SUBSTATE_COUNT(55,0);

          _SFD_ST_SUBSTATE_COUNT(56,0);

          _SFD_ST_SUBSTATE_COUNT(59,0);

          _SFD_ST_SUBSTATE_COUNT(61,2);

          _SFD_ST_SUBSTATE_INDEX(61,0,62);

          _SFD_ST_SUBSTATE_INDEX(61,1,63);

          _SFD_ST_SUBSTATE_COUNT(62,0);

          _SFD_ST_SUBSTATE_COUNT(63,2);

          _SFD_ST_SUBSTATE_INDEX(63,0,64);

          _SFD_ST_SUBSTATE_INDEX(63,1,71);

          _SFD_ST_SUBSTATE_COUNT(64,5);

          _SFD_ST_SUBSTATE_INDEX(64,0,65);

          _SFD_ST_SUBSTATE_INDEX(64,1,66);

          _SFD_ST_SUBSTATE_INDEX(64,2,67);

          _SFD_ST_SUBSTATE_INDEX(64,3,68);

          _SFD_ST_SUBSTATE_INDEX(64,4,69);

          _SFD_ST_SUBSTATE_COUNT(65,0);

          _SFD_ST_SUBSTATE_COUNT(66,0);

          _SFD_ST_SUBSTATE_COUNT(67,0);

          _SFD_ST_SUBSTATE_COUNT(68,0);

          _SFD_ST_SUBSTATE_COUNT(69,0);

          _SFD_ST_SUBSTATE_COUNT(71,0);

          _SFD_ST_SUBSTATE_COUNT(73,0);

          _SFD_ST_SUBSTATE_COUNT(74,2);

          _SFD_ST_SUBSTATE_INDEX(74,0,75);

          _SFD_ST_SUBSTATE_INDEX(74,1,76);

          _SFD_ST_SUBSTATE_COUNT(75,0);

          _SFD_ST_SUBSTATE_COUNT(76,0);

          _SFD_ST_SUBSTATE_COUNT(79,4);

          _SFD_ST_SUBSTATE_INDEX(79,0,80);

          _SFD_ST_SUBSTATE_INDEX(79,1,81);

          _SFD_ST_SUBSTATE_INDEX(79,2,82);

          _SFD_ST_SUBSTATE_INDEX(79,3,83);

          _SFD_ST_SUBSTATE_COUNT(80,0);

          _SFD_ST_SUBSTATE_COUNT(81,0);

          _SFD_ST_SUBSTATE_COUNT(82,0);

          _SFD_ST_SUBSTATE_COUNT(83,0);

          _SFD_ST_SUBSTATE_COUNT(7,6);

          _SFD_ST_SUBSTATE_INDEX(7,0,8);

          _SFD_ST_SUBSTATE_INDEX(7,1,18);

          _SFD_ST_SUBSTATE_INDEX(7,2,20);

          _SFD_ST_SUBSTATE_INDEX(7,3,21);

          _SFD_ST_SUBSTATE_INDEX(7,4,22);

          _SFD_ST_SUBSTATE_INDEX(7,5,33);

          _SFD_ST_SUBSTATE_COUNT(8,4);

          _SFD_ST_SUBSTATE_INDEX(8,0,9);

          _SFD_ST_SUBSTATE_INDEX(8,1,12);

          _SFD_ST_SUBSTATE_INDEX(8,2,13);

          _SFD_ST_SUBSTATE_INDEX(8,3,14);

          _SFD_ST_SUBSTATE_COUNT(9,2);

          _SFD_ST_SUBSTATE_INDEX(9,0,10);

          _SFD_ST_SUBSTATE_INDEX(9,1,11);

          _SFD_ST_SUBSTATE_COUNT(10,0);

          _SFD_ST_SUBSTATE_COUNT(11,0);

          _SFD_ST_SUBSTATE_COUNT(12,0);

          _SFD_ST_SUBSTATE_COUNT(13,0);

          _SFD_ST_SUBSTATE_COUNT(14,3);

          _SFD_ST_SUBSTATE_INDEX(14,0,15);

          _SFD_ST_SUBSTATE_INDEX(14,1,16);

          _SFD_ST_SUBSTATE_INDEX(14,2,17);

          _SFD_ST_SUBSTATE_COUNT(15,0);

          _SFD_ST_SUBSTATE_COUNT(16,0);

          _SFD_ST_SUBSTATE_COUNT(17,0);

          _SFD_ST_SUBSTATE_COUNT(18,0);

          _SFD_ST_SUBSTATE_COUNT(20,0);

          _SFD_ST_SUBSTATE_COUNT(21,0);

          _SFD_ST_SUBSTATE_COUNT(22,4);

          _SFD_ST_SUBSTATE_INDEX(22,0,23);

          _SFD_ST_SUBSTATE_INDEX(22,1,24);

          _SFD_ST_SUBSTATE_INDEX(22,2,27);

          _SFD_ST_SUBSTATE_INDEX(22,3,30);

          _SFD_ST_SUBSTATE_COUNT(23,0);

          _SFD_ST_SUBSTATE_COUNT(24,2);

          _SFD_ST_SUBSTATE_INDEX(24,0,25);

          _SFD_ST_SUBSTATE_INDEX(24,1,26);

          _SFD_ST_SUBSTATE_COUNT(25,0);

          _SFD_ST_SUBSTATE_COUNT(26,0);

          _SFD_ST_SUBSTATE_COUNT(27,2);

          _SFD_ST_SUBSTATE_INDEX(27,0,28);

          _SFD_ST_SUBSTATE_INDEX(27,1,29);

          _SFD_ST_SUBSTATE_COUNT(28,0);

          _SFD_ST_SUBSTATE_COUNT(29,0);

          _SFD_ST_SUBSTATE_COUNT(30,2);

          _SFD_ST_SUBSTATE_INDEX(30,0,31);

          _SFD_ST_SUBSTATE_INDEX(30,1,32);

          _SFD_ST_SUBSTATE_COUNT(31,0);

          _SFD_ST_SUBSTATE_COUNT(32,0);

          _SFD_ST_SUBSTATE_COUNT(33,0);

          _SFD_ST_SUBSTATE_COUNT(87,3);

          _SFD_ST_SUBSTATE_INDEX(87,0,88);

          _SFD_ST_SUBSTATE_INDEX(87,1,89);

          _SFD_ST_SUBSTATE_INDEX(87,2,90);

          _SFD_ST_SUBSTATE_COUNT(88,0);

          _SFD_ST_SUBSTATE_COUNT(89,0);

          _SFD_ST_SUBSTATE_COUNT(90,0);

          _SFD_ST_SUBSTATE_COUNT(84,1);

          _SFD_ST_SUBSTATE_INDEX(84,0,85);

          _SFD_ST_SUBSTATE_COUNT(85,0);

          _SFD_ST_SUBSTATE_COUNT(4,2);

          _SFD_ST_SUBSTATE_INDEX(4,0,5);

          _SFD_ST_SUBSTATE_INDEX(4,1,6);

          _SFD_ST_SUBSTATE_COUNT(5,0);

          _SFD_ST_SUBSTATE_COUNT(6,0);

          _SFD_ST_SUBSTATE_COUNT(0,2);

          _SFD_ST_SUBSTATE_INDEX(0,0,1);

          _SFD_ST_SUBSTATE_INDEX(0,1,2);

          _SFD_ST_SUBSTATE_COUNT(1,0);

          _SFD_ST_SUBSTATE_COUNT(2,0);

        }



        _SFD_CV_INIT_CHART(7,0,0,0);



        {

          _SFD_CV_INIT_STATE(0,2,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(1,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(2,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(4,2,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(5,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(6,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(7,6,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(8,4,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(9,2,1,1,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 91 };



          static unsigned int sEndSaturateMap[] = { 92 };



          _SFD_CV_INIT_STATE_SATURATION(9,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(10,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(11,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(12,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 119 };



          static unsigned int sEndSaturateMap[] = { 120 };



          _SFD_CV_INIT_STATE_SATURATION(12,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(13,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 141 };



          static unsigned int sEndSaturateMap[] = { 142 };



          _SFD_CV_INIT_STATE_SATURATION(13,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(14,3,1,1,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 92 };



          static unsigned int sEndSaturateMap[] = { 93 };



          _SFD_CV_INIT_STATE_SATURATION(14,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(15,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(16,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(17,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(18,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(20,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(21,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(22,4,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(23,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 114 };



          static unsigned int sEndSaturateMap[] = { 115 };



          _SFD_CV_INIT_STATE_SATURATION(23,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(24,2,1,1,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 89 };



          static unsigned int sEndSaturateMap[] = { 90 };



          _SFD_CV_INIT_STATE_SATURATION(24,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(25,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(26,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(27,2,1,1,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 92 };



          static unsigned int sEndSaturateMap[] = { 93 };



          _SFD_CV_INIT_STATE_SATURATION(27,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(28,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(29,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(30,2,1,1,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 52, 94 };



          static unsigned int sEndSaturateMap[] = { 53, 95 };



          _SFD_CV_INIT_STATE_SATURATION(30,2,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(31,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(32,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(33,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(35,5,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(36,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(37,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(38,5,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(39,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 129 };



          static unsigned int sEndSaturateMap[] = { 130 };



          _SFD_CV_INIT_STATE_SATURATION(39,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(40,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 143, 213, 87 };



          static unsigned int sEndSaturateMap[] = { 144, 214, 92 };



          _SFD_CV_INIT_STATE_SATURATION(40,3,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(41,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 60 };



          static unsigned int sEndSaturateMap[] = { 68 };



          _SFD_CV_INIT_STATE_SATURATION(41,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(42,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 155 };



          static unsigned int sEndSaturateMap[] = { 156 };



          _SFD_CV_INIT_STATE_SATURATION(42,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(43,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 120, 284, 320, 457 };



          static unsigned int sEndSaturateMap[] = { 125, 285, 321, 458 };



          _SFD_CV_INIT_STATE_SATURATION(43,4,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(45,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(47,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(48,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(49,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(50,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(51,5,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(52,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 139 };



          static unsigned int sEndSaturateMap[] = { 140 };



          _SFD_CV_INIT_STATE_SATURATION(52,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(53,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 32 };



          static unsigned int sEndSaturateMap[] = { 36 };



          _SFD_CV_INIT_STATE_SATURATION(53,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(54,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(55,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 64 };



          static unsigned int sEndSaturateMap[] = { 72 };



          _SFD_CV_INIT_STATE_SATURATION(55,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(56,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 165 };



          static unsigned int sEndSaturateMap[] = { 166 };



          _SFD_CV_INIT_STATE_SATURATION(56,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(59,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(61,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(62,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(63,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(64,5,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(65,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 139 };



          static unsigned int sEndSaturateMap[] = { 140 };



          _SFD_CV_INIT_STATE_SATURATION(65,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(66,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 155, 233, 93 };



          static unsigned int sEndSaturateMap[] = { 156, 234, 98 };



          _SFD_CV_INIT_STATE_SATURATION(66,3,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(67,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 64 };



          static unsigned int sEndSaturateMap[] = { 72 };



          _SFD_CV_INIT_STATE_SATURATION(67,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(68,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 165 };



          static unsigned int sEndSaturateMap[] = { 166 };



          _SFD_CV_INIT_STATE_SATURATION(68,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(69,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 121, 287, 320, 464 };



          static unsigned int sEndSaturateMap[] = { 126, 288, 321, 465 };



          _SFD_CV_INIT_STATE_SATURATION(69,4,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(71,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(73,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 38 };



          static unsigned int sEndSaturateMap[] = { 53 };



          _SFD_CV_INIT_STATE_SATURATION(73,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(74,2,1,1,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(75,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(76,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(79,4,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(80,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(81,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(82,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(83,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(84,1,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(85,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(87,3,1,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(88,0,0,0,0,0,NULL,NULL);

        }



        {

          static unsigned int sStartSaturateMap[] = { 120 };



          static unsigned int sEndSaturateMap[] = { 121 };



          _SFD_CV_INIT_STATE_SATURATION(88,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          _SFD_CV_INIT_STATE(89,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(90,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(19,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(34,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(44,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(46,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(57,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(58,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(60,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(70,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(72,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(77,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(78,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(86,0,0,0,0,0,NULL,NULL);

        }



        {

          _SFD_CV_INIT_STATE(3,0,0,0,0,0,NULL,NULL);

        }



        _SFD_CV_INIT_TRANS(145,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(78,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 20 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(79,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 20 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(79,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 29 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(137,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(138,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 33 };



          static unsigned int sEndGuardMap[] = { 29, 61 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(143,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 33 };



          static unsigned int sEndRelationalopMap[] = { 29, 61 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

            1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(143,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 60 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(179,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 32 };



          static unsigned int sEndRelationalopMap[] = { 28, 60 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

            1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(179,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 60 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(187,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 32 };



          static unsigned int sEndRelationalopMap[] = { 28, 60 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

            1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(187,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 60 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(144,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 32 };



          static unsigned int sEndRelationalopMap[] = { 28, 60 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

            1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(144,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 27 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(139,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(140,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(178,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 32 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(141,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(177,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(186,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 25 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(185,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(136,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(126,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 34 };



          static unsigned int sEndGuardMap[] = { 30, 62 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(127,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 30 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(127,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(128,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(129,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 3, 34, 68 };



          static unsigned int sEndGuardMap[] = { 29, 63, 99 };



          static int sPostFixPredicateTree[] = { 0, -1, 1, -1, -3, 2, -2 };



          _SFD_CV_INIT_TRANS(130,3,&(sStartGuardMap[0]),&(sEndGuardMap[0]),7,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(131,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(132,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(122,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 28 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(123,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 28 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(123,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(125,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(124,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 2 };



          static unsigned int sEndGuardMap[] = { 32 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(80,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 2 };



          static unsigned int sEndRelationalopMap[] = { 32 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(80,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(82,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(81,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartSaturateMap[] = { 130 };



          static unsigned int sEndSaturateMap[] = { 131 };



          _SFD_CV_INIT_TRANSITION_SATURATION(81,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 33 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(83,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 33 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(83,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(85,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(84,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartSaturateMap[] = { 136 };



          static unsigned int sEndSaturateMap[] = { 137 };



          _SFD_CV_INIT_TRANSITION_SATURATION(84,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 39 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(86,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 39 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(86,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(88,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(87,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 41 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(89,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 41 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(89,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(91,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(90,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(142,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 28 };



          static unsigned int sEndGuardMap[] = { 24, 48 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(100,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 24 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(100,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 48 };



          static unsigned int sEndGuardMap[] = { 44, 61 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(111,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 48 };



          static unsigned int sEndRelationalopMap[] = { 44, 61 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1,

            5, 1, 5, 1, 5, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(111,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(105,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(107,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 16 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(103,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 16 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(103,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 16 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(106,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 16 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(106,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 28, 51 };



          static unsigned int sEndGuardMap[] = { 24, 47, 101 };



          static int sPostFixPredicateTree[] = { 0, 1, -3, 2, -3 };



          _SFD_CV_INIT_TRANS(101,3,&(sStartGuardMap[0]),&(sEndGuardMap[0]),5,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 51 };



          static unsigned int sEndRelationalopMap[] = { 24, 101 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5,

            1, 5, 1, 5, 1, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(101,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 16 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(102,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 16 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(102,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 23 };



          static unsigned int sEndGuardMap[] = { 19, 72 };



          static int sPostFixPredicateTree[] = { 0, 1, -2 };



          _SFD_CV_INIT_TRANS(110,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 23 };



          static unsigned int sEndRelationalopMap[] = { 19, 72 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

            3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(110,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(112,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 15 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(104,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 15 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(104,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(113,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 22 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(133,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 22 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(133,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(135,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(134,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 74 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(114,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartSaturateMap[] = { 12 };



          static unsigned int sEndSaturateMap[] = { 26 };



          _SFD_CV_INIT_TRANSITION_SATURATION(114,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 74 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(114,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(115,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(116,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 80 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(117,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartSaturateMap[] = { 16 };



          static unsigned int sEndSaturateMap[] = { 30 };



          _SFD_CV_INIT_TRANSITION_SATURATION(117,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 80 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(117,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(118,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(119,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartSaturateMap[] = { 53 };



          static unsigned int sEndSaturateMap[] = { 54 };



          _SFD_CV_INIT_TRANSITION_SATURATION(119,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        _SFD_CV_INIT_TRANS(108,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(109,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(151,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 60 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(153,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 28 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(153,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 56 };



          static unsigned int sEndGuardMap[] = { 52, 69 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(154,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 56 };



          static unsigned int sEndRelationalopMap[] = { 52, 69 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1,

            5, 1, 5, 1, 5, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(154,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(156,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(157,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(158,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(158,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(159,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(159,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 32, 59 };



          static unsigned int sEndGuardMap[] = { 28, 55, 106 };



          static int sPostFixPredicateTree[] = { 0, 1, -3, 2, -3 };



          _SFD_CV_INIT_TRANS(160,3,&(sStartGuardMap[0]),&(sEndGuardMap[0]),5,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 59 };



          static unsigned int sEndRelationalopMap[] = { 28, 106 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5,

            1, 5, 1, 5, 1, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(160,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(161,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(161,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 25 };



          static unsigned int sEndGuardMap[] = { 21, 71 };



          static int sPostFixPredicateTree[] = { 0, 1, -2 };



          _SFD_CV_INIT_TRANS(162,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 25 };



          static unsigned int sEndRelationalopMap[] = { 21, 71 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

            3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(162,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(163,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 17 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(164,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 17 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(164,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(165,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 22 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(166,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 22 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(166,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(167,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(168,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 71 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(169,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartSaturateMap[] = { 12 };



          static unsigned int sEndSaturateMap[] = { 28 };



          _SFD_CV_INIT_TRANSITION_SATURATION(169,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 71 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(169,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(170,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(171,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 76 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(172,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartSaturateMap[] = { 16 };



          static unsigned int sEndSaturateMap[] = { 32 };



          _SFD_CV_INIT_TRANSITION_SATURATION(172,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 76 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(172,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(173,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(174,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartSaturateMap[] = { 53 };



          static unsigned int sEndSaturateMap[] = { 54 };



          _SFD_CV_INIT_TRANSITION_SATURATION(174,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        _SFD_CV_INIT_TRANS(175,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(176,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 58 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(183,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 28 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(183,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(189,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(190,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(191,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(192,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(193,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(194,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(195,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(184,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(202,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(203,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(201,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(200,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(199,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(198,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(197,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(196,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(204,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(209,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 60 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(211,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 28 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(211,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 18 };



          static unsigned int sEndGuardMap[] = { 14, 31 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(212,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 18 };



          static unsigned int sEndRelationalopMap[] = { 14, 31 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1,

            5, 1, 5, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(212,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(214,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(215,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(216,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(216,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(217,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(217,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 32, 59 };



          static unsigned int sEndGuardMap[] = { 28, 55, 106 };



          static int sPostFixPredicateTree[] = { 0, 1, -3, 2, -3 };



          _SFD_CV_INIT_TRANS(218,3,&(sStartGuardMap[0]),&(sEndGuardMap[0]),5,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 59 };



          static unsigned int sEndRelationalopMap[] = { 28, 106 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5,

            1, 5, 1, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(218,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(232,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(232,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 19 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(219,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 19 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(219,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(220,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 22 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(221,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 22 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(221,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(222,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(223,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 71 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(224,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartSaturateMap[] = { 12 };



          static unsigned int sEndSaturateMap[] = { 28 };



          _SFD_CV_INIT_TRANSITION_SATURATION(224,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 71 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(224,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(225,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(226,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 77 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(227,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartSaturateMap[] = { 16 };



          static unsigned int sEndSaturateMap[] = { 32 };



          _SFD_CV_INIT_TRANSITION_SATURATION(227,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 77 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(227,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(228,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(229,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartSaturateMap[] = { 53 };



          static unsigned int sEndSaturateMap[] = { 54 };



          _SFD_CV_INIT_TRANSITION_SATURATION(229,1,&(sStartSaturateMap[0]),

            &(sEndSaturateMap[0]));

        }



        _SFD_CV_INIT_TRANS(230,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(231,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 0 };



          static unsigned int sEndGuardMap[] = { 13 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(92,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(13,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 0 };



          static unsigned int sEndGuardMap[] = { 11 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(14,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 27 };



          static unsigned int sEndGuardMap[] = { 23, 47 };



          static int sPostFixPredicateTree[] = { 0, 1, -2 };



          _SFD_CV_INIT_TRANS(17,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 14 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(180,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 14 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(180,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 27 };



          static unsigned int sEndGuardMap[] = { 23, 47 };



          static int sPostFixPredicateTree[] = { 0, 1, -2 };



          _SFD_CV_INIT_TRANS(15,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 0 };



          static unsigned int sEndGuardMap[] = { 19 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(16,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 0, 12, 28 };



          static unsigned int sEndGuardMap[] = { 11, 24, 41 };



          static int sPostFixPredicateTree[] = { 0, 1, 2, -2, -3 };



          _SFD_CV_INIT_TRANS(2,3,&(sStartGuardMap[0]),&(sEndGuardMap[0]),5,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 12, 28 };



          static unsigned int sEndRelationalopMap[] = { 24, 41 };



          static int sRelationalopEps[] = { 0, 0 };



          static int sRelationalopType[] = { 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0,

            2, 0, 2, 0, 2, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(2,2,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(7,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(7,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(8,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(1,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(18,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 0 };



          static unsigned int sEndGuardMap[] = { 13 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(3,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(12,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(12,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(6,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(6,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(4,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(4,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(5,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(5,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(65,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(66,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 34 };



          static unsigned int sEndGuardMap[] = { 30, 53 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(64,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 34 };



          static unsigned int sEndRelationalopMap[] = { 53 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(64,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(75,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(76,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 2 };



          static unsigned int sEndGuardMap[] = { 31 };



          static int sPostFixPredicateTree[] = { 0, -1 };



          _SFD_CV_INIT_TRANS(77,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),2,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(61,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(63,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 34 };



          static unsigned int sEndGuardMap[] = { 30, 53 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(62,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 34 };



          static unsigned int sEndRelationalopMap[] = { 53 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(62,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(11,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(11,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(10,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(10,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(9,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(9,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(68,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 36 };



          static unsigned int sEndGuardMap[] = { 30, 55 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(67,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 36 };



          static unsigned int sEndRelationalopMap[] = { 55 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(67,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(70,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 2, 37 };



          static unsigned int sEndGuardMap[] = { 33, 56 };



          static int sPostFixPredicateTree[] = { 0, -1, 1, -3 };



          _SFD_CV_INIT_TRANS(69,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),4,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 37 };



          static unsigned int sEndRelationalopMap[] = { 56 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(69,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(71,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(210,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(73,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(74,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 19 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(72,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 19 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 2, 2, 2, 2, 2, 2, 2, 2, 2 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(72,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(205,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 12 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(206,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 12 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(206,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(208,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(207,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(19,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 24 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(20,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 30 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(34,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(21,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(36,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(35,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 23 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(22,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 30 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(48,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(49,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(56,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(23,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 26 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(24,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 30 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(37,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(25,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(38,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(39,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 14 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(46,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 14 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(46,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(57,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(52,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 24 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(26,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 30 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(40,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 14 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(51,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 14 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(51,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(58,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(27,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(41,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(42,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(50,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 28 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(28,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 14 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(54,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 14 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(54,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(59,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(29,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(43,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(55,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 27 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(30,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 14 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(47,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 14 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(47,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(60,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(31,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(44,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(53,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 30 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(32,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        _SFD_CV_INIT_TRANS(33,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(45,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(98,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(99,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(148,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(149,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { -1 };



          static int sRelationalopType[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(149,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(150,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(95,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(96,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 23 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(146,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 23 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(146,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 23 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(93,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1, 1, 1 };



          static unsigned int sEndRelationalopMap[] = { 23, 23, 23 };



          static int sRelationalopEps[] = { 0, 0, 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(93,3,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(97,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 18 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(94,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 18 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 3, 3, 3, 3, 3, 3, 3, 3, 3 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(94,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(147,0,NULL,NULL,0,NULL);

        _SFD_CV_INIT_TRANS(182,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 66 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(181,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 66 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(181,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        {

          static unsigned int sStartGuardMap[] = { 1, 28 };



          static unsigned int sEndGuardMap[] = { 24, 50 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(121,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 24 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(121,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(120,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1, 32 };



          static unsigned int sEndGuardMap[] = { 28, 58 };



          static int sPostFixPredicateTree[] = { 0, 1, -3 };



          _SFD_CV_INIT_TRANS(152,2,&(sStartGuardMap[0]),&(sEndGuardMap[0]),3,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 28 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(152,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(155,0,NULL,NULL,0,NULL);



        {

          static unsigned int sStartGuardMap[] = { 1 };



          static unsigned int sEndGuardMap[] = { 16 };



          static int sPostFixPredicateTree[] = { 0 };



          _SFD_CV_INIT_TRANS(188,1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),1,

                             &(sPostFixPredicateTree[0]));

        }



        {

          static unsigned int sStartRelationalopMap[] = { 1 };



          static unsigned int sEndRelationalopMap[] = { 16 };



          static int sRelationalopEps[] = { 0 };



          static int sRelationalopType[] = { 0, 0, 0, 0, 0, 0, 0, 0 };



          _SFD_CV_INIT_TRANSITION_RELATIONALOP(188,1,&(sStartRelationalopMap[0]),

            &(sEndRelationalopMap[0]),&(sRelationalopEps[0]),

            &(sRelationalopType[0]));

        }



        _SFD_CV_INIT_TRANS(213,0,NULL,NULL,0,NULL);

        _SFD_SET_DATA_COMPILED_PROPS(0,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(1,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(2,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(3,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(4,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(5,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(6,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(7,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(8,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(9,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(10,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(11,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(12,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(13,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(14,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(15,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(16,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(17,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(18,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)c1_b_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(19,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)c1_b_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(20,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(21,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(22,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)c1_b_sf_marshallIn);



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(23,SF_UINT16,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_d_sf_marshallOut,(MexInFcnForType)

            c1_f_sf_marshallIn);

        }



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(24,SF_UINT16,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_d_sf_marshallOut,(MexInFcnForType)NULL);

        }



        _SFD_SET_DATA_COMPILED_PROPS(25,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)NULL);



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(26,SF_UINT16,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_d_sf_marshallOut,(MexInFcnForType)NULL);

        }



        _SFD_SET_DATA_COMPILED_PROPS(27,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)NULL);



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(28,SF_UINT16,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_d_sf_marshallOut,(MexInFcnForType)NULL);

        }



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 16U;

          _SFD_SET_DATA_COMPILED_PROPS(29,SF_INT32,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_f_sf_marshallOut,(MexInFcnForType)NULL);

        }



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 24U;

          _SFD_SET_DATA_COMPILED_PROPS(30,SF_INT32,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_g_sf_marshallOut,(MexInFcnForType)NULL);

        }



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(31,SF_UINT16,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_d_sf_marshallOut,(MexInFcnForType)NULL);

        }



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 16U;

          _SFD_SET_DATA_COMPILED_PROPS(32,SF_INT32,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_f_sf_marshallOut,(MexInFcnForType)NULL);

        }



        _SFD_SET_DATA_COMPILED_PROPS(33,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)NULL);



        {

          unsigned int dimVector[2];

          dimVector[0]= 1U;

          dimVector[1]= 8U;

          _SFD_SET_DATA_COMPILED_PROPS(34,SF_INT32,2,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_h_sf_marshallOut,(MexInFcnForType)NULL);

        }



        _SFD_SET_DATA_COMPILED_PROPS(35,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);



        {

          unsigned int dimVector[1];

          dimVector[0]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(36,SF_UINT32,1,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_i_sf_marshallOut,(MexInFcnForType)NULL);

        }



        _SFD_SET_DATA_COMPILED_PROPS(37,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(38,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(39,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(40,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(41,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(42,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(43,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(44,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(45,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(46,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(47,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)c1_b_sf_marshallIn);



        {

          unsigned int dimVector[1];

          dimVector[0]= 2U;

          _SFD_SET_DATA_COMPILED_PROPS(48,SF_UINT16,1,&(dimVector[0]),0,0,0,0.0,

            1.0,0,0,(MexFcnForType)c1_c_sf_marshallOut,(MexInFcnForType)

            c1_c_sf_marshallIn);

        }



        _SFD_SET_DATA_COMPILED_PROPS(49,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(50,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)c1_b_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(51,SF_UINT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_j_sf_marshallOut,(MexInFcnForType)c1_e_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(52,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)c1_d_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(53,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(54,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(55,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(56,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(57,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(58,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(59,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(60,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(61,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(62,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(63,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(64,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(65,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(66,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(67,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(68,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(69,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(70,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(71,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(72,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(73,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(74,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(75,SF_UINT16,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_e_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(76,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)NULL);

        _SFD_SET_DATA_COMPILED_PROPS(77,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_n_sf_marshallOut,(MexInFcnForType)c1_j_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(78,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_n_sf_marshallOut,(MexInFcnForType)c1_j_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(79,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_m_sf_marshallOut,(MexInFcnForType)c1_i_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(80,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)c1_b_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(81,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(82,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(83,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(84,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(85,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(86,SF_INT32,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(87,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_k_sf_marshallOut,(MexInFcnForType)c1_g_sf_marshallIn);

        _SFD_SET_DATA_COMPILED_PROPS(88,SF_UINT8,0,NULL,0,0,0,0.0,1.0,0,0,

          (MexFcnForType)c1_l_sf_marshallOut,(MexInFcnForType)c1_h_sf_marshallIn);

        _SFD_SET_DATA_VALUE_PTR(77,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(78,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(79,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(80,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(81,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(82,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(83,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(84,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(85,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(86,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(87,(void *)(NULL));

        _SFD_SET_DATA_VALUE_PTR(88,(void *)(NULL));

      }

    } else {

      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,

        _GCU_Model_genCodeMachineNumber_,chartInstance->chartNumber,

        chartInstance->instanceNumber);

    }

  }

}



static void chart_debug_initialize_data_addresses(SimStruct *S)

{

  if (!sim_mode_is_rtw_gen(S)) {

    SFc1_GCU_Model_genCodeInstanceStruct *chartInstance =

      (SFc1_GCU_Model_genCodeInstanceStruct *)sf_get_chart_instance_ptr(S);

    if (ssIsFirstInitCond(S)) {

      /* do this only if simulation is starting and after we know the addresses of all data */

      {

        _SFD_SET_DATA_VALUE_PTR(47U, (void *)chartInstance->c1_clutchCurrVal);

        _SFD_SET_DATA_VALUE_PTR(48U, (void *)chartInstance->c1_lastModeCom);

        _SFD_SET_DATA_VALUE_PTR(24U, (void *)chartInstance->c1_shiftCom);

        _SFD_SET_DATA_VALUE_PTR(25U, (void *)chartInstance->c1_startEngCom);

        _SFD_SET_DATA_VALUE_PTR(26U, (void *)chartInstance->c1_aacCom);

        _SFD_SET_DATA_VALUE_PTR(27U, (void *)chartInstance->c1_clutchTarget);

        _SFD_SET_DATA_VALUE_PTR(22U, (void *)&chartInstance->c1_lastShift);

        _SFD_SET_DATA_VALUE_PTR(28U, (void *)chartInstance->c1_modeCom);

        _SFD_SET_DATA_VALUE_PTR(49U, (void *)chartInstance->c1_stateFb);

        _SFD_SET_DATA_VALUE_PTR(29U, (void *)chartInstance->c1_acc_parameters);

        _SFD_SET_DATA_VALUE_PTR(30U, (void *)chartInstance->c1_timings);

        _SFD_SET_DATA_VALUE_PTR(31U, (void *)chartInstance->c1_autoXCom);

        _SFD_SET_DATA_VALUE_PTR(32U, (void *)chartInstance->c1_autoX_parameters);

        _SFD_SET_DATA_VALUE_PTR(33U, (void *)chartInstance->c1_slipUpdateCounter);

        _SFD_SET_DATA_VALUE_PTR(50U, (void *)chartInstance->c1_antiStallEnable);

        _SFD_SET_DATA_VALUE_PTR(34U, (void *)

          chartInstance->c1_antiStall_parameters);

        _SFD_SET_DATA_VALUE_PTR(35U, (void *)chartInstance->c1_antiStallFb);

        _SFD_SET_DATA_VALUE_PTR(36U, (void *)

          chartInstance->c1_gearMotorCurent_1_2);

        _SFD_SET_DATA_VALUE_PTR(37U, (void *)chartInstance->c1_currGear);

        _SFD_SET_DATA_VALUE_PTR(38U, (void *)chartInstance->c1_currTps);

        _SFD_SET_DATA_VALUE_PTR(39U, (void *)chartInstance->c1_currRpm);

        _SFD_SET_DATA_VALUE_PTR(40U, (void *)chartInstance->c1_currVhSpeed);

        _SFD_SET_DATA_VALUE_PTR(41U, (void *)chartInstance->c1_currSlip);

        _SFD_SET_DATA_VALUE_PTR(42U, (void *)chartInstance->c1_currSlipTarget);

        _SFD_SET_DATA_VALUE_PTR(43U, (void *)chartInstance->c1_pidSubMode);

        _SFD_SET_DATA_VALUE_PTR(51U, (void *)chartInstance->c1_pidCounter);

        _SFD_SET_DATA_VALUE_PTR(44U, (void *)chartInstance->c1_I1_L);

        _SFD_SET_DATA_VALUE_PTR(45U, (void *)chartInstance->c1_I2_L);

        _SFD_SET_DATA_VALUE_PTR(46U, (void *)chartInstance->c1_canErrorCom);

        _SFD_SET_DATA_VALUE_PTR(23U, (void *)&chartInstance->c1_lastTryShift);

        _SFD_SET_DATA_VALUE_PTR(52U, (void *)chartInstance->c1_rpmAccTarget);

        _SFD_SET_DATA_VALUE_PTR(1U, (void *)&chartInstance->c1_lastAacCom);

        _SFD_SET_DATA_VALUE_PTR(3U, (void *)&chartInstance->c1_lastShiftCom);

        _SFD_SET_DATA_VALUE_PTR(2U, (void *)&chartInstance->c1_lastAutoXCom);

        _SFD_SET_DATA_VALUE_PTR(0U, (void *)&chartInstance->c1_buzzerCounter);

        _SFD_SET_DATA_VALUE_PTR(55U, (void *)

          &chartInstance->c1_GEAR_COMMAND_NEUTRAL_UP);

        _SFD_SET_DATA_VALUE_PTR(54U, (void *)

          &chartInstance->c1_GEAR_COMMAND_NEUTRAL_DOWN);

        _SFD_SET_DATA_VALUE_PTR(56U, (void *)&chartInstance->c1_GEAR_COMMAND_UP);

        _SFD_SET_DATA_VALUE_PTR(53U, (void *)

          &chartInstance->c1_GEAR_COMMAND_DOWN);

        _SFD_SET_DATA_VALUE_PTR(59U, (void *)

          &chartInstance->c1_b_GEAR_COMMAND_NEUTRAL_UP);

        _SFD_SET_DATA_VALUE_PTR(58U, (void *)

          &chartInstance->c1_b_GEAR_COMMAND_NEUTRAL_DOWN);

        _SFD_SET_DATA_VALUE_PTR(60U, (void *)

          &chartInstance->c1_b_GEAR_COMMAND_UP);

        _SFD_SET_DATA_VALUE_PTR(57U, (void *)

          &chartInstance->c1_b_GEAR_COMMAND_DOWN);

        _SFD_SET_DATA_VALUE_PTR(61U, (void *)&chartInstance->c1_AAC_WORK_RATE_ms);

        _SFD_SET_DATA_VALUE_PTR(4U, (void *)&chartInstance->c1_aacCounter);

        _SFD_SET_DATA_VALUE_PTR(6U, (void *)&chartInstance->c1_aac_clutchValue);

        _SFD_SET_DATA_VALUE_PTR(5U, (void *)&chartInstance->c1_aac_clutchStep);

        _SFD_SET_DATA_VALUE_PTR(7U, (void *)&chartInstance->c1_aac_dtRelease);

        _SFD_SET_DATA_VALUE_PTR(64U, (void *)&chartInstance->c1_DEF_RAMP_START);

        _SFD_SET_DATA_VALUE_PTR(63U, (void *)&chartInstance->c1_DEF_RAMP_END);

        _SFD_SET_DATA_VALUE_PTR(65U, (void *)&chartInstance->c1_DEF_RAMP_TIME);

        _SFD_SET_DATA_VALUE_PTR(66U, (void *)

          &chartInstance->c1_DEF_RPM_LIMIT_1_2);

        _SFD_SET_DATA_VALUE_PTR(67U, (void *)

          &chartInstance->c1_DEF_RPM_LIMIT_2_3);

        _SFD_SET_DATA_VALUE_PTR(68U, (void *)

          &chartInstance->c1_DEF_RPM_LIMIT_3_4);

        _SFD_SET_DATA_VALUE_PTR(69U, (void *)

          &chartInstance->c1_DEF_RPM_LIMIT_4_5);

        _SFD_SET_DATA_VALUE_PTR(70U, (void *)

          &chartInstance->c1_DEF_SPEED_LIMIT_1_2);

        _SFD_SET_DATA_VALUE_PTR(71U, (void *)

          &chartInstance->c1_DEF_SPEED_LIMIT_2_3);

        _SFD_SET_DATA_VALUE_PTR(72U, (void *)

          &chartInstance->c1_DEF_SPEED_LIMIT_3_4);

        _SFD_SET_DATA_VALUE_PTR(73U, (void *)

          &chartInstance->c1_DEF_SPEED_LIMIT_4_5);

        _SFD_SET_DATA_VALUE_PTR(62U, (void *)&chartInstance->c1_ACC_CODE);

        _SFD_SET_DATA_VALUE_PTR(74U, (void *)

          &chartInstance->c1_AUTOX_WORK_RATE_ms);

        _SFD_SET_DATA_VALUE_PTR(8U, (void *)&chartInstance->c1_autoXCounter);

        _SFD_SET_DATA_VALUE_PTR(10U, (void *)

          &chartInstance->c1_autoX_clutchValue);

        _SFD_SET_DATA_VALUE_PTR(9U, (void *)&chartInstance->c1_autoX_clutchStep);

        _SFD_SET_DATA_VALUE_PTR(11U, (void *)&chartInstance->c1_autoX_dtRelease);

        _SFD_SET_DATA_VALUE_PTR(75U, (void *)

          &chartInstance->c1_b_AUTOX_WORK_RATE_ms);

        _SFD_SET_DATA_VALUE_PTR(12U, (void *)&chartInstance->c1_b_autoXCounter);

        _SFD_SET_DATA_VALUE_PTR(14U, (void *)

          &chartInstance->c1_b_autoX_clutchValue);

        _SFD_SET_DATA_VALUE_PTR(13U, (void *)

          &chartInstance->c1_b_autoX_clutchStep);

        _SFD_SET_DATA_VALUE_PTR(15U, (void *)

          &chartInstance->c1_b_autoX_dtRelease);

        _SFD_SET_DATA_VALUE_PTR(16U, (void *)&chartInstance->c1_ticksCounter);

        _SFD_SET_DATA_VALUE_PTR(76U, (void *)&chartInstance->c1_data);

        _SFD_SET_DATA_VALUE_PTR(17U, (void *)&chartInstance->c1_counterWait);

        _SFD_SET_DATA_VALUE_PTR(18U, (void *)&chartInstance->c1_lastCom);

        _SFD_SET_DATA_VALUE_PTR(19U, (void *)&chartInstance->c1_startCounter);

        _SFD_SET_DATA_VALUE_PTR(20U, (void *)&chartInstance->c1_timerCounter);

        _SFD_SET_DATA_VALUE_PTR(21U, (void *)&chartInstance->c1_b_counterWait);

      }

    }

  }

}



static const char* sf_get_instance_specialization(void)

{

  return "srj7xHgy15kFbhIXyeRBAxD";

}



static void sf_opaque_initialize_c1_GCU_Model_genCode(void *chartInstanceVar)

{

  chart_debug_initialization(((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar)->S,0);

  initialize_params_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar);

  initialize_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar);

}



static void sf_opaque_enable_c1_GCU_Model_genCode(void *chartInstanceVar)

{

  enable_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar);

}



static void sf_opaque_disable_c1_GCU_Model_genCode(void *chartInstanceVar)

{

  disable_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar);

}



static void sf_opaque_gateway_c1_GCU_Model_genCode(void *chartInstanceVar)

{

  sf_gateway_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar);

}



static const mxArray* sf_opaque_get_sim_state_c1_GCU_Model_genCode(SimStruct* S)

{

  return get_sim_state_c1_GCU_Model_genCode

    ((SFc1_GCU_Model_genCodeInstanceStruct *)sf_get_chart_instance_ptr(S));/* raw sim ctx */

}



static void sf_opaque_set_sim_state_c1_GCU_Model_genCode(SimStruct* S, const

  mxArray *st)

{

  set_sim_state_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    sf_get_chart_instance_ptr(S), st);

}



static void sf_opaque_terminate_c1_GCU_Model_genCode(void *chartInstanceVar)

{

  if (chartInstanceVar!=NULL) {

    SimStruct *S = ((SFc1_GCU_Model_genCodeInstanceStruct*) chartInstanceVar)->S;

    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {

      sf_clear_rtw_identifier(S);

      unload_GCU_Model_genCode_optimization_info();

    }



    finalize_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

      chartInstanceVar);

    if (!sim_mode_is_rtw_gen(S)) {

      ssSetModelMappingInfoPtr(S, NULL);

    }



    utFree(chartInstanceVar);

    if (ssGetUserData(S)!= NULL) {

      sf_free_ChartRunTimeInfo(S);

    }



    ssSetUserData(S,NULL);

  }

}



static void sf_opaque_init_subchart_simstructs(void *chartInstanceVar)

{

  initSimStructsc1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

    chartInstanceVar);

}



extern unsigned int sf_machine_global_initializer_called(void);

static void mdlProcessParameters_c1_GCU_Model_genCode(SimStruct *S)

{

  int i;

  for (i=0;i<ssGetNumRunTimeParams(S);i++) {

    if (ssGetSFcnParamTunable(S,i)) {

      ssUpdateDlgParamAsRunTimeParam(S,i);

    }

  }



  if (sf_machine_global_initializer_called()) {

    initialize_params_c1_GCU_Model_genCode((SFc1_GCU_Model_genCodeInstanceStruct*)

      sf_get_chart_instance_ptr(S));

  }

}



static void mdlSetWorkWidths_c1_GCU_Model_genCode(SimStruct *S)

{

  ssSetInputPortDirectFeedThrough(S, 0, 1);

  ssSetInputPortDirectFeedThrough(S, 1, 1);

  ssSetInputPortDirectFeedThrough(S, 2, 1);

  ssSetInputPortDirectFeedThrough(S, 3, 1);

  ssSetInputPortDirectFeedThrough(S, 4, 1);

  ssSetInputPortDirectFeedThrough(S, 5, 1);

  ssSetInputPortDirectFeedThrough(S, 6, 1);

  ssSetInputPortDirectFeedThrough(S, 7, 1);

  ssSetInputPortDirectFeedThrough(S, 8, 1);

  ssSetInputPortDirectFeedThrough(S, 9, 1);

  ssSetInputPortDirectFeedThrough(S, 10, 1);

  ssSetInputPortDirectFeedThrough(S, 11, 1);

  ssSetInputPortDirectFeedThrough(S, 12, 1);

  ssSetInputPortDirectFeedThrough(S, 13, 1);

  ssSetInputPortDirectFeedThrough(S, 14, 1);

  ssSetInputPortDirectFeedThrough(S, 15, 1);

  ssSetInputPortDirectFeedThrough(S, 16, 1);

  ssSetInputPortDirectFeedThrough(S, 17, 1);

  ssSetInputPortDirectFeedThrough(S, 18, 1);

  ssSetInputPortDirectFeedThrough(S, 19, 1);

  ssSetInputPortDirectFeedThrough(S, 20, 1);

  ssSetInputPortDirectFeedThrough(S, 21, 1);

  ssSetInputPortDirectFeedThrough(S, 22, 1);

  ssSetInputPortDirectFeedThrough(S, 23, 1);

  ssSetInputPortDirectFeedThrough(S, 24, 1);

  ssSetInputPortDirectFeedThrough(S, 25, 1);

  ssSetInputPortDirectFeedThrough(S, 26, 1);

  ssSetInputPortDirectFeedThrough(S, 27, 1);

  ssSetInputPortDirectFeedThrough(S, 28, 1);

  ssSetInputPortDirectFeedThrough(S, 29, 1);

  ssSetInputPortDirectFeedThrough(S, 30, 1);

  ssSetInputPortDirectFeedThrough(S, 31, 1);

  ssSetInputPortDirectFeedThrough(S, 32, 1);

  ssSetInputPortDirectFeedThrough(S, 33, 1);

  ssSetInputPortDirectFeedThrough(S, 34, 1);

  ssSetStatesModifiedOnlyInUpdate(S, 0);

  ssSetBlockIsPurelyCombinatorial_wrapper(S, 0);

  ssMdlUpdateIsEmpty(S, 1);

  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {

    mxArray *infoStruct = load_GCU_Model_genCode_optimization_info

      (sim_mode_is_rtw_gen(S), sim_mode_is_modelref_sim(S), sim_mode_is_external

       (S));

    int_T chartIsInlinable =

      (int_T)sf_is_chart_inlinable(sf_get_instance_specialization(),infoStruct,1);

    ssSetStateflowIsInlinable(S,chartIsInlinable);

    ssSetRTWCG(S,1);

    ssSetSupportedForRowMajorCodeGen(S, 1);

    ssSetEnableFcnIsTrivial(S,1);

    ssSetDisableFcnIsTrivial(S,1);

    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop

      (sf_get_instance_specialization(),infoStruct,1,

       "gatewayCannotBeInlinedMultipleTimes"));

    sf_set_chart_accesses_machine_info(S, sf_get_instance_specialization(),

      infoStruct, 1);

    sf_update_buildInfo(S, sf_get_instance_specialization(),infoStruct,1);

    sf_mark_output_events_with_multiple_callers(S,sf_get_instance_specialization

      (),infoStruct,1,31);

    if (chartIsInlinable) {

      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 2, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 3, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 4, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 5, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 6, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 7, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 8, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 9, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 10, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 11, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 12, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 13, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 14, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 15, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 16, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 17, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 18, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 19, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 20, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 21, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 22, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 23, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 24, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 25, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 26, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 27, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 28, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 29, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 30, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 31, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 32, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 33, SS_REUSABLE_AND_LOCAL);

      ssSetInputPortOptimOpts(S, 34, SS_REUSABLE_AND_LOCAL);

      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),

        infoStruct,1,23);

      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),

        infoStruct,1,28);

    }



    {

      unsigned int outPortIdx;

      for (outPortIdx=1; outPortIdx<=28; ++outPortIdx) {

        ssSetOutputPortOptimizeInIR(S, outPortIdx, 1U);

      }

    }



    {

      unsigned int inPortIdx;

      for (inPortIdx=0; inPortIdx < 35; ++inPortIdx) {

        ssSetInputPortOptimizeInIR(S, inPortIdx, 1U);

      }

    }



    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,1);

    sf_register_codegen_names_for_scoped_functions_defined_by_chart(S);

    ssSetHasSubFunctions(S,!(chartIsInlinable));

  } else {

  }



  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);

  ssSetChecksum0(S,(1297789585U));

  ssSetChecksum1(S,(4105989974U));

  ssSetChecksum2(S,(1239995913U));

  ssSetChecksum3(S,(4271397656U));

  ssSetmdlDerivatives(S, NULL);

  ssSetExplicitFCSSCtrl(S,1);

  ssSetStateSemanticsClassicAndSynchronous(S, true);

  ssSupportsMultipleExecInstances(S,1);

}



static void mdlRTW_c1_GCU_Model_genCode(SimStruct *S)

{

  if (sim_mode_is_rtw_gen(S)) {

    ssWriteRTWStrParam(S, "StateflowChartType", "Stateflow");

  }

}



static void mdlStart_c1_GCU_Model_genCode(SimStruct *S)

{

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance;

  chartInstance = (SFc1_GCU_Model_genCodeInstanceStruct *)utMalloc(sizeof

    (SFc1_GCU_Model_genCodeInstanceStruct));

  if (chartInstance==NULL) {

    sf_mex_error_message("Could not allocate memory for chart instance.");

  }



  memset(chartInstance, 0, sizeof(SFc1_GCU_Model_genCodeInstanceStruct));

  chartInstance->chartInfo.chartInstance = chartInstance;

  chartInstance->chartInfo.isEMLChart = 0;

  chartInstance->chartInfo.chartInitialized = 0;

  chartInstance->chartInfo.sFunctionGateway =

    sf_opaque_gateway_c1_GCU_Model_genCode;

  chartInstance->chartInfo.initializeChart =

    sf_opaque_initialize_c1_GCU_Model_genCode;

  chartInstance->chartInfo.terminateChart =

    sf_opaque_terminate_c1_GCU_Model_genCode;

  chartInstance->chartInfo.enableChart = sf_opaque_enable_c1_GCU_Model_genCode;

  chartInstance->chartInfo.disableChart = sf_opaque_disable_c1_GCU_Model_genCode;

  chartInstance->chartInfo.getSimState =

    sf_opaque_get_sim_state_c1_GCU_Model_genCode;

  chartInstance->chartInfo.setSimState =

    sf_opaque_set_sim_state_c1_GCU_Model_genCode;

  chartInstance->chartInfo.getSimStateInfo =

    sf_get_sim_state_info_c1_GCU_Model_genCode;

  chartInstance->chartInfo.zeroCrossings = NULL;

  chartInstance->chartInfo.outputs = NULL;

  chartInstance->chartInfo.derivatives = NULL;

  chartInstance->chartInfo.mdlRTW = mdlRTW_c1_GCU_Model_genCode;

  chartInstance->chartInfo.mdlStart = mdlStart_c1_GCU_Model_genCode;

  chartInstance->chartInfo.mdlSetWorkWidths =

    mdlSetWorkWidths_c1_GCU_Model_genCode;

  chartInstance->chartInfo.callGetHoverDataForMsg =

    sf_opaque_get_hover_data_for_msg;

  chartInstance->chartInfo.extModeExec = NULL;

  chartInstance->chartInfo.restoreLastMajorStepConfiguration = NULL;

  chartInstance->chartInfo.restoreBeforeLastMajorStepConfiguration = NULL;

  chartInstance->chartInfo.storeCurrentConfiguration = NULL;

  chartInstance->chartInfo.callAtomicSubchartUserFcn = NULL;

  chartInstance->chartInfo.callAtomicSubchartAutoFcn = NULL;

  chartInstance->chartInfo.callAtomicSubchartEventFcn = NULL;

  chartInstance->chartInfo.debugInstance = sfGlobalDebugInstanceStruct;

  chartInstance->S = S;

  sf_init_ChartRunTimeInfo(S, &(chartInstance->chartInfo), false, 0);

  init_dsm_address_info(chartInstance);

  init_simulink_io_address(chartInstance);

  if (!sim_mode_is_rtw_gen(S)) {

    init_test_point_mapping_info(S);

  }



  chart_debug_initialization(S,1);

  mdl_start_c1_GCU_Model_genCode(chartInstance);

}



void c1_GCU_Model_genCode_method_dispatcher(SimStruct *S, int_T method, void

  *data)

{

  switch (method) {

   case SS_CALL_MDL_START:

    mdlStart_c1_GCU_Model_genCode(S);

    break;



   case SS_CALL_MDL_SET_WORK_WIDTHS:

    mdlSetWorkWidths_c1_GCU_Model_genCode(S);

    break;



   case SS_CALL_MDL_PROCESS_PARAMETERS:

    mdlProcessParameters_c1_GCU_Model_genCode(S);

    break;



   default:

    /* Unhandled method */

    sf_mex_error_message("Stateflow Internal Error:\n"

                         "Error calling c1_GCU_Model_genCode_method_dispatcher.\n"

                         "Can't handle method %d.\n", method);

    break;

  }

}



static const rtwCAPI_DataTypeMap dataTypeMap[] = {

  /* cName, mwName, numElements, elemMapIndex, dataSize, slDataId, isComplex, isPointer */

  { "uint16_T", "uint16_T", 0, 0, sizeof(uint16_T), SS_UINT16, 0, 0 },



  { "uint8_T", "uint8_T", 0, 0, sizeof(uint8_T), SS_UINT8, 0, 0 } };



static real_T sfCAPIsampleTimeZero = 0.0;

static const rtwCAPI_SampleTimeMap sampleTimeMap[] = {

  /* *period, *offset, taskId, mode */

  { &sfCAPIsampleTimeZero, &sfCAPIsampleTimeZero, 0, 0 }

};



static const rtwCAPI_DimensionMap dimensionMap[] = {

  /* dataOrientation, dimArrayIndex, numDims*/

  { rtwCAPI_SCALAR, 0, 2 } };



static const rtwCAPI_Signals testPointSignals[] = {

  /* addrMapIndex, sysNum, SFRelativePath, dataName, portNumber, dataTypeIndex, dimIndex, fixPtIdx, sTimeIndex */

  { 0, 0, "StateflowChart/clutchCurrVal", "clutchCurrVal", 0, 1, 0, 0, 0 },



  { 1, 0, "StateflowChart/MODES.ACCELERATION.ACC.aacCounter", "aacCounter", 0, 0,

    0, 0, 0 },



  { 2, 0, "StateflowChart/MODES.AUTOCROSS.LAUNCH.autoXCounter", "autoXCounter",

    0, 0, 0, 0, 0 },



  { 3, 0, "StateflowChart/MODES.ACCELERATION_PID.LAUNCH0.autoXCounter",

    "autoXCounter", 0, 0, 0, 0, 0 } };



static const rtwCAPI_FixPtMap fixedPointMap[] = {

  /* *fracSlope, *bias, scaleType, wordLength, exponent, isSigned */

  { NULL, NULL, rtwCAPI_FIX_RESERVED, 64, 0, 0 } };



static const uint_T dimensionArray[] = {

  1, 1 };



static rtwCAPI_ModelMappingStaticInfo testPointMappingStaticInfo = {

  /* block signal monitoring */

  {

    testPointSignals,                  /* Block signals Array  */

    4,                                 /* Num Block IO signals */

    NULL,                              /* Root Inputs Array    */

    0,                                 /* Num root inputs      */

    NULL,                              /* Root Outputs Array */

    0                                  /* Num root outputs   */

  },



  /* parameter tuning */

  {

    NULL,                              /* Block parameters Array    */

    0,                                 /* Num block parameters      */

    NULL,                              /* Variable parameters Array */

    0                                  /* Num variable parameters   */

  },



  /* block states */

  {

    NULL,                              /* Block States array        */

    0                                  /* Num Block States          */

  },



  /* Static maps */

  {

    dataTypeMap,                       /* Data Type Map            */

    dimensionMap,                      /* Data Dimension Map       */

    fixedPointMap,                     /* Fixed Point Map          */

    NULL,                              /* Structure Element map    */

    sampleTimeMap,                     /* Sample Times Map         */

    dimensionArray                     /* Dimension Array          */

  },



  /* Target type */

  "float",



  {

    1297789585U,

    4105989974U,

    1239995913U,

    4271397656U

  }

};



static void init_test_point_mapping_info(SimStruct *S)

{

  rtwCAPI_ModelMappingInfo *testPointMappingInfo;

  void **testPointAddrMap;

  SFc1_GCU_Model_genCodeInstanceStruct *chartInstance =

    (SFc1_GCU_Model_genCodeInstanceStruct *)sf_get_chart_instance_ptr(S);

  init_test_point_addr_map(chartInstance);

  testPointMappingInfo = get_test_point_mapping_info(chartInstance);

  testPointAddrMap = get_test_point_address_map(chartInstance);

  rtwCAPI_SetStaticMap(*testPointMappingInfo, &testPointMappingStaticInfo);

  rtwCAPI_SetLoggingStaticMap(*testPointMappingInfo, NULL);

  rtwCAPI_SetInstanceLoggingInfo(*testPointMappingInfo, NULL);

  rtwCAPI_SetPath(*testPointMappingInfo, "");

  rtwCAPI_SetFullPath(*testPointMappingInfo, NULL);

  rtwCAPI_SetDataAddressMap(*testPointMappingInfo, testPointAddrMap);

  rtwCAPI_SetChildMMIArray(*testPointMappingInfo, NULL);

  rtwCAPI_SetChildMMIArrayLen(*testPointMappingInfo, 0);

  ssSetModelMappingInfoPtr(S, testPointMappingInfo);

}